src/game_mm/mm_game.c

   1 // ============================================================================
   2 // Mirror Magic -- McDuffin's Revenge
   3 // ----------------------------------------------------------------------------
   4 // (c) 1994-2017 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  http://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // mm_game.c
  10 // ============================================================================
  11
  12 #include <math.h>
  13
  14 #include "main_mm.h"
  15
  16 #include "mm_main.h"
  17 #include "mm_game.h"
  18 #include "mm_tools.h"
  19
  20 /* graphic position values for game controls */
  21 #define ENERGY_XSIZE            32
  22 #define ENERGY_YSIZE            MAX_LASER_ENERGY
  23 #define OVERLOAD_XSIZE          ENERGY_XSIZE
  24 #define OVERLOAD_YSIZE          MAX_LASER_OVERLOAD
  25
  26 /* values for Explode_MM() */
  27 #define EX_PHASE_START          0
  28 #define EX_NORMAL               0
  29 #define EX_KETTLE               1
  30 #define EX_SHORT                2
  31
  32 /* special positions in the game control window (relative to control window) */
  33 #define XX_LEVEL                36
  34 #define YY_LEVEL                23
  35 #define XX_KETTLES              29
  36 #define YY_KETTLES              63
  37 #define XX_SCORE                22
  38 #define YY_SCORE                101
  39 #define XX_ENERGY               8
  40 #define YY_ENERGY               158
  41 #define XX_OVERLOAD             60
  42 #define YY_OVERLOAD             YY_ENERGY
  43
  44 /* special positions in the game control window (relative to main window) */
  45 #define DX_LEVEL                (DX + XX_LEVEL)
  46 #define DY_LEVEL                (DY + YY_LEVEL)
  47 #define DX_KETTLES              (DX + XX_KETTLES)
  48 #define DY_KETTLES              (DY + YY_KETTLES)
  49 #define DX_SCORE                (DX + XX_SCORE)
  50 #define DY_SCORE                (DY + YY_SCORE)
  51 #define DX_ENERGY               (DX + XX_ENERGY)
  52 #define DY_ENERGY               (DY + YY_ENERGY)
  53 #define DX_OVERLOAD             (DX + XX_OVERLOAD)
  54 #define DY_OVERLOAD             (DY + YY_OVERLOAD)
  55
  56 #define IS_LOOP_SOUND(s)        ((s) == SND_FUEL)
  57 #define IS_MUSIC_SOUND(s)       ((s) == SND_TYGER || (s) == SND_VOYAGER)
  58
  59 /* game button identifiers */
  60 #define GAME_CTRL_ID_LEFT       0
  61 #define GAME_CTRL_ID_MIDDLE     1
  62 #define GAME_CTRL_ID_RIGHT      2
  63
  64 #define NUM_GAME_BUTTONS        3
  65
  66 /* values for DrawLaser() */
  67 #define DL_LASER_DISABLED       0
  68 #define DL_LASER_ENABLED        1
  69
  70 /* values for 'click_delay_value' in ClickElement() */
  71 #define CLICK_DELAY_FIRST       12      /* delay (frames) after first click */
  72 #define CLICK_DELAY             6       /* delay (frames) for pressed butten */
  73
  74 #define AUTO_ROTATE_DELAY       CLICK_DELAY
  75 #define INIT_GAME_ACTIONS_DELAY (ONE_SECOND_DELAY / GAME_FRAME_DELAY)
  76 #define NUM_INIT_CYCLE_STEPS    16
  77 #define PACMAN_MOVE_DELAY       12
  78 #define ENERGY_DELAY            (ONE_SECOND_DELAY / GAME_FRAME_DELAY)
  79 #define HEALTH_DEC_DELAY        3
  80 #define HEALTH_INC_DELAY        9
  81 #define HEALTH_DELAY(x)         ((x) ? HEALTH_DEC_DELAY : HEALTH_INC_DELAY)
  82
  83 #define BEGIN_NO_HEADLESS                       \
  84   {                                             \
  85     boolean last_headless = program.headless;   \
  86                                                 \
  87     program.headless = FALSE;                   \
  88
  89 #define END_NO_HEADLESS                         \
  90     program.headless = last_headless;           \
  91   }                                             \
  92
  93 /* forward declaration for internal use */
  94 static int MovingOrBlocked2Element_MM(int, int);
  95 static void Bang_MM(int, int);
  96 static void RaiseScore_MM(int);
  97 static void RaiseScoreElement_MM(int);
  98 static void RemoveMovingField_MM(int, int);
  99 static void InitMovingField_MM(int, int, int);
 100 static void ContinueMoving_MM(int, int);
 101 static void Moving2Blocked_MM(int, int, int *, int *);
 102
 103 /* bitmap for laser beam detection */
 104 static Bitmap *laser_bitmap = NULL;
 105
 106 /* variables for laser control */
 107 static int last_LX = 0, last_LY = 0, last_hit_mask = 0;
 108 static int hold_x = -1, hold_y = -1;
 109
 110 /* variables for pacman control */
 111 static int pacman_nr = -1;
 112
 113 /* various game engine delay counters */
 114 static unsigned int rotate_delay = 0;
 115 static unsigned int pacman_delay = 0;
 116 static unsigned int energy_delay = 0;
 117 static unsigned int overload_delay = 0;
 118
 119 /* element masks for scanning pixels of MM elements */
 120 static const char mm_masks[10][16][16 + 1] =
 121 {
 122   {
 123     "                ",
 124     "    XXXXX       ",
 125     "   XXXXXXX      ",
 126     "  XXXXXXXXXXX   ",
 127     "  XXXXXXXXXXXXX ",
 128     "  XXXXXXXXXXXXXX",
 129     "  XXXXXXXXXXXXXX",
 130     "  XXXXXXXXXXXXX ",
 131     "  XXXXXXXXXXXXX ",
 132     "  XXXXXXXXXXXXX ",
 133     "  XXXXXXXXXXXXX ",
 134     "  XXXXXXXXXXXXX ",
 135     "  XXXXXXXXXXXXX ",
 136     "  XXXXXXXXXXXXX ",
 137     "  XXXXXXXXXXXX  ",
 138     "  XXXXXXXXXXXX  ",
 139   },
 140   {
 141     "                ",
 142     "    XXXXXXXX    ",
 143     "  XXXXXXXXXXXX  ",
 144     " XXXXXXXXXXXXXX ",
 145     " XXXXXXXXXXXXXX ",
 146     " XXXXXXXXXXXXXX ",
 147     " XXXXXXXXXXXXXX ",
 148     " XXXXXXXXXXXXXX ",
 149     " XXXXXXXXXXXXXX ",
 150     " XXXXXXXXXXXXXX ",
 151     " XXXXXXXXXXXXXX ",
 152     " XXXXXXXXXXXXXX ",
 153     " XXXXXXXXXXXXXX ",
 154     "  XXXXXXXXXXXXX ",
 155     "  XXXXXXXXXXXX  ",
 156     "  XXXXXXXXXXXX  ",
 157   },
 158   {
 159     "                ",
 160     "    XXXXXX      ",
 161     "  XXXXXXXXX     ",
 162     " XXXXXXXXXXX    ",
 163     "XXXXXXXXXXXXX   ",
 164     "XXXXXXXXXXXXX   ",
 165     "XXXXXXXXXXXXXX  ",
 166     " XXXXXXXXXXXXX  ",
 167     " XXXXXXXXXXXXX  ",
 168     " XXXXXXXXXXXXX  ",
 169     " XXXXXXXXXXXXX  ",
 170     " XXXXXXXXXXXXX  ",
 171     " XXXXXXXXXXXXX  ",
 172     " XXXXXXXXXXXXX  ",
 173     "  XXXXXXXXXXXX  ",
 174     "  XXXXXXXXXXXX  ",
 175   },
 176   {
 177     "                ",
 178     "    XXXXXX      ",
 179     "   XXXXXXXX     ",
 180     "  XXXXXXXXXX    ",
 181     "  XXXXXXXXXXX   ",
 182     "  XXXXXXXXXXX   ",
 183     "  XXXXXXXXXXXX  ",
 184     "  XXXXXXXXXXXX  ",
 185     "  XXXXXXXXXXXX  ",
 186     "  XXXXXXXXXXXX  ",
 187     "  XXXXXXXXXXXX  ",
 188     "  XXXXXXXXXXXX  ",
 189     "  XXXXXXXXXXXX  ",
 190     "  XXXXXXXXXXXX  ",
 191     "  XXXXXXXXXXXX  ",
 192     "  XXXXX  XXXXX  ",
 193   },
 194   {
 195     " XXXXXX  XXXXXX ",
 196     "XXXXXXXXXXXXXXXX",
 197     "XXXXXXXXXXXXXXXX",
 198     "XXXXXXXXXXXXXXXX",
 199     "XXXXXXXXXXXXXXXX",
 200     "XXXXXXXXXXXXXXXX",
 201     "XXXXXXXXXXXXXXXX",
 202     "                ",
 203     "                ",
 204     "XXXXXXXXXXXXXXXX",
 205     "XXXXXXXXXXXXXXXX",
 206     "XXXXXXXXXXXXXXXX",
 207     "XXXXXXXXXXXXXXXX",
 208     "XXXXXXXXXXXXXXXX",
 209     "XXXXXXXXXXXXXXXX",
 210     " XXXXXX  XXXXXX ",
 211   },
 212   {
 213     " XXXXXX  XXXXXX ",
 214     "XXXXXXX  XXXXXXX",
 215     "XXXXXXX  XXXXXXX",
 216     "XXXXXXX  XXXXXXX",
 217     "XXXXXXX  XXXXXXX",
 218     "XXXXXXX  XXXXXXX",
 219     "XXXXXXX  XXXXXXX",
 220     " XXXXXX  XXXXXX ",
 221     " XXXXXX  XXXXXX ",
 222     "XXXXXXX  XXXXXXX",
 223     "XXXXXXX  XXXXXXX",
 224     "XXXXXXX  XXXXXXX",
 225     "XXXXXXX  XXXXXXX",
 226     "XXXXXXX  XXXXXXX",
 227     "XXXXXXX  XXXXXXX",
 228     " XXXXXX  XXXXXX ",
 229   },
 230   {
 231     "     XX  XXXXX  ",
 232     "    XXX  XXXX   ",
 233     "   XXXX  XXX   X",
 234     "  XXXXXXXXX   XX",
 235     " XXXXXXXXX   XXX",
 236     "XXXXXXXXX   XXXX",
 237     "XXXXXXXX   XXXXX",
 238     "   XXXX   XXX   ",
 239     "   XXX   XXXX   ",
 240     "XXXXX   XXXXXXXX",
 241     "XXXX   XXXXXXXXX",
 242     "XXX   XXXXXXXXX ",
 243     "XX   XXXXXXXXX  ",
 244     "X   XXX  XXXX   ",
 245     "   XXXX  XXX    ",
 246     "  XXXXX  XX     ",
 247   },
 248   {
 249     "  XXXXX  XX     ",
 250     "   XXXX  XXX    ",
 251     "X   XXX  XXXX   ",
 252     "XX   XXXXXXXXX  ",
 253     "XXX   XXXXXXXXX ",
 254     "XXXX   XXXXXXXXX",
 255     "XXXXX   XXXXXXXX",
 256     "   XXX   XXXX   ",
 257     "   XXXX   XXX   ",
 258     "XXXXXXXX   XXXXX",
 259     "XXXXXXXXX   XXXX",
 260     " XXXXXXXXX   XXX",
 261     "  XXXXXXXXX   XX",
 262     "   XXXX  XXX   X",
 263     "    XXX  XXXX   ",
 264     "     XX  XXXXX  ",
 265   },
 266   {
 267     "XXXXXXXXXXXXXXXX",
 268     "XXXXXXXXXXXXXXXX",
 269     "XXXXXXXXXXXXXXXX",
 270     "XXXXXXXXXXXXXXXX",
 271     "XXXXXXXXXXXXXXXX",
 272     "XXXXXXXXXXXXXXXX",
 273     "XXXXXXXXXXXXXXXX",
 274     "XXXXXXXXXXXXXXXX",
 275     "XXXXXXXXXXXXXXXX",
 276     "XXXXXXXXXXXXXXXX",
 277     "XXXXXXXXXXXXXXXX",
 278     "XXXXXXXXXXXXXXXX",
 279     "XXXXXXXXXXXXXXXX",
 280     "XXXXXXXXXXXXXXXX",
 281     "XXXXXXXXXXXXXXXX",
 282     "XXXXXXXXXXXXXXXX",
 283   },
 284   {
 285     "                ",
 286     "      XXXX      ",
 287     "    XXXXXXXX    ",
 288     "   XXXXXXXXXX   ",
 289     "  XXXXXXXXXXXX  ",
 290     "  XXXXXXXXXXXX  ",
 291     " XXXXXXXXXXXXXX ",
 292     " XXXXXXXXXXXXXX ",
 293     " XXXXXXXXXXXXXX ",
 294     " XXXXXXXXXXXXXX ",
 295     "  XXXXXXXXXXXX  ",
 296     "  XXXXXXXXXXXX  ",
 297     "   XXXXXXXXXX   ",
 298     "    XXXXXXXX    ",
 299     "      XXXX      ",
 300     "                ",
 301   },
 302 };
 303
 304 static int get_element_angle(int element)
 305 {
 306   int element_phase = get_element_phase(element);
 307
 308   if (IS_MIRROR_FIXED(element) ||
 309       IS_MCDUFFIN(element) ||
 310       IS_LASER(element) ||
 311       IS_RECEIVER(element))
 312     return 4 * element_phase;
 313   else
 314     return element_phase;
 315 }
 316
 317 static int get_opposite_angle(int angle)
 318 {
 319   int opposite_angle = angle + ANG_RAY_180;
 320
 321   /* make sure "opposite_angle" is in valid interval [0, 15] */
 322   return (opposite_angle + 16) % 16;
 323 }
 324
 325 static int get_mirrored_angle(int laser_angle, int mirror_angle)
 326 {
 327   int reflected_angle = 16 - laser_angle + mirror_angle;
 328
 329   /* make sure "reflected_angle" is in valid interval [0, 15] */
 330   return (reflected_angle + 16) % 16;
 331 }
 332
 333 static void DrawLaserLines(struct XY *points, int num_points, int mode)
 334 {
 335   Pixel pixel_drawto = (mode == DL_LASER_ENABLED ? pen_ray     : pen_bg);
 336   Pixel pixel_buffer = (mode == DL_LASER_ENABLED ? WHITE_PIXEL : BLACK_PIXEL);
 337
 338   DrawLines(drawto, points, num_points, pixel_drawto);
 339
 340   BEGIN_NO_HEADLESS
 341   {
 342     DrawLines(laser_bitmap, points, num_points, pixel_buffer);
 343   }
 344   END_NO_HEADLESS
 345 }
 346
 347 static boolean CheckLaserPixel(int x, int y)
 348 {
 349   Pixel pixel;
 350
 351   BEGIN_NO_HEADLESS
 352   {
 353     pixel = ReadPixel(laser_bitmap, x, y);
 354   }
 355   END_NO_HEADLESS
 356
 357   return (pixel == WHITE_PIXEL);
 358 }
 359
 360 static void CheckExitMM()
 361 {
 362   int exit_element = EL_EMPTY;
 363   int exit_x = 0;
 364   int exit_y = 0;
 365   int x, y;
 366   static int xy[4][2] =
 367   {
 368     { +1,  0 },
 369     {  0, -1 },
 370     { -1,  0 },
 371     {  0, +1 }
 372   };
 373
 374   for (y = 0; y < lev_fieldy; y++)
 375   {
 376     for (x = 0; x < lev_fieldx; x++)
 377     {
 378       if (Feld[x][y] == EL_EXIT_CLOSED)
 379       {
 380         /* initiate opening animation of exit door */
 381         Feld[x][y] = EL_EXIT_OPENING;
 382
 383         exit_element = EL_EXIT_OPEN;
 384         exit_x = x;
 385         exit_y = y;
 386       }
 387       else if (IS_RECEIVER(Feld[x][y]))
 388       {
 389         /* remove field that blocks receiver */
 390         int phase = Feld[x][y] - EL_RECEIVER_START;
 391         int blocking_x, blocking_y;
 392
 393         blocking_x = x + xy[phase][0];
 394         blocking_y = y + xy[phase][1];
 395
 396         if (IN_LEV_FIELD(blocking_x, blocking_y))
 397         {
 398           Feld[blocking_x][blocking_y] = EL_EMPTY;
 399
 400           DrawField_MM(blocking_x, blocking_y);
 401         }
 402
 403         exit_element = EL_RECEIVER;
 404         exit_x = x;
 405         exit_y = y;
 406       }
 407     }
 408   }
 409
 410   if (exit_element != EL_EMPTY)
 411     PlayLevelSound_MM(exit_x, exit_y, exit_element, MM_ACTION_OPENING);
 412 }
 413
 414 static void InitMovDir_MM(int x, int y)
 415 {
 416   int element = Feld[x][y];
 417   static int direction[3][4] =
 418   {
 419     { MV_RIGHT, MV_UP,    MV_LEFT,  MV_DOWN },
 420     { MV_LEFT,  MV_DOWN,  MV_RIGHT, MV_UP   },
 421     { MV_LEFT,  MV_RIGHT, MV_UP,    MV_DOWN }
 422   };
 423
 424   switch(element)
 425   {
 426     case EL_PACMAN_RIGHT:
 427     case EL_PACMAN_UP:
 428     case EL_PACMAN_LEFT:
 429     case EL_PACMAN_DOWN:
 430       Feld[x][y] = EL_PACMAN;
 431       MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
 432       break;
 433
 434     default:
 435       break;
 436   }
 437 }
 438
 439 static void InitField(int x, int y, boolean init_game)
 440 {
 441   int element = Feld[x][y];
 442
 443   switch (element)
 444   {
 445     case EL_DF_EMPTY:
 446       Feld[x][y] = EL_EMPTY;
 447       break;
 448
 449     case EL_KETTLE:
 450     case EL_CELL:
 451       if (native_mm_level.auto_count_kettles)
 452         game_mm.kettles_still_needed++;
 453       break;
 454
 455     case EL_LIGHTBULB_OFF:
 456       game_mm.lights_still_needed++;
 457       break;
 458
 459     default:
 460       if (IS_MIRROR(element) ||
 461           IS_BEAMER_OLD(element) ||
 462           IS_BEAMER(element) ||
 463           IS_POLAR(element) ||
 464           IS_POLAR_CROSS(element) ||
 465           IS_DF_MIRROR(element) ||
 466           IS_DF_MIRROR_AUTO(element) ||
 467           IS_GRID_STEEL_AUTO(element) ||
 468           IS_GRID_WOOD_AUTO(element) ||
 469           IS_FIBRE_OPTIC(element))
 470       {
 471         if (IS_BEAMER_OLD(element))
 472         {
 473           Feld[x][y] = EL_BEAMER_BLUE_START + (element - EL_BEAMER_START);
 474           element = Feld[x][y];
 475         }
 476
 477         if (!IS_FIBRE_OPTIC(element))
 478         {
 479           static int steps_grid_auto = 0;
 480
 481           if (game_mm.num_cycle == 0)   /* initialize cycle steps for grids */
 482             steps_grid_auto = RND(16) * (RND(2) ? -1 : +1);
 483
 484           if (IS_GRID_STEEL_AUTO(element) ||
 485               IS_GRID_WOOD_AUTO(element))
 486             game_mm.cycle[game_mm.num_cycle].steps = steps_grid_auto;
 487           else
 488             game_mm.cycle[game_mm.num_cycle].steps = RND(16) * (RND(2) ? -1 : +1);
 489
 490           game_mm.cycle[game_mm.num_cycle].x = x;
 491           game_mm.cycle[game_mm.num_cycle].y = y;
 492           game_mm.num_cycle++;
 493         }
 494
 495         if (IS_BEAMER(element) || IS_FIBRE_OPTIC(element))
 496         {
 497           int beamer_nr = BEAMER_NR(element);
 498           int nr = laser.beamer[beamer_nr][0].num;
 499
 500           laser.beamer[beamer_nr][nr].x = x;
 501           laser.beamer[beamer_nr][nr].y = y;
 502           laser.beamer[beamer_nr][nr].num = 1;
 503         }
 504       }
 505       else if (IS_PACMAN(element))
 506       {
 507         InitMovDir_MM(x, y);
 508       }
 509       else if (IS_MCDUFFIN(element) || IS_LASER(element))
 510       {
 511         laser.start_edge.x = x;
 512         laser.start_edge.y = y;
 513         laser.start_angle = get_element_angle(element);
 514       }
 515
 516       break;
 517   }
 518 }
 519
 520 static void InitCycleElements_RotateSingleStep()
 521 {
 522   int i;
 523
 524   if (game_mm.num_cycle == 0)   /* no elements to cycle */
 525     return;
 526
 527   for (i = 0; i < game_mm.num_cycle; i++)
 528   {
 529     int x = game_mm.cycle[i].x;
 530     int y = game_mm.cycle[i].y;
 531     int step = SIGN(game_mm.cycle[i].steps);
 532     int last_element = Feld[x][y];
 533     int next_element = get_rotated_element(last_element, step);
 534
 535     if (!game_mm.cycle[i].steps)
 536       continue;
 537
 538     Feld[x][y] = next_element;
 539
 540     DrawField_MM(x, y);
 541     game_mm.cycle[i].steps -= step;
 542   }
 543 }
 544
 545 static void InitLaser()
 546 {
 547   int start_element = Feld[laser.start_edge.x][laser.start_edge.y];
 548   int step = (IS_LASER(start_element) ? 4 : 0);
 549
 550   LX = laser.start_edge.x * TILEX;
 551   if (laser.start_angle == ANG_RAY_UP || laser.start_angle == ANG_RAY_DOWN)
 552     LX += 14;
 553   else
 554     LX += (laser.start_angle == ANG_RAY_RIGHT ? 28 + step : 0 - step);
 555
 556   LY = laser.start_edge.y * TILEY;
 557   if (laser.start_angle == ANG_RAY_UP || laser.start_angle == ANG_RAY_DOWN)
 558     LY += (laser.start_angle == ANG_RAY_DOWN ? 28 + step : 0 - step);
 559   else
 560     LY += 14;
 561
 562   XS = 2 * Step[laser.start_angle].x;
 563   YS = 2 * Step[laser.start_angle].y;
 564
 565   laser.current_angle = laser.start_angle;
 566
 567   laser.num_damages = 0;
 568   laser.num_edges = 0;
 569   laser.num_beamers = 0;
 570   laser.beamer_edge[0] = 0;
 571
 572   laser.dest_element = EL_EMPTY;
 573   laser.wall_mask = 0;
 574
 575   AddLaserEdge(LX, LY);         /* set laser starting edge */
 576
 577   pen_ray = GetPixelFromRGB(window,
 578                             native_mm_level.laser_red   * 0xFF,
 579                             native_mm_level.laser_green * 0xFF,
 580                             native_mm_level.laser_blue  * 0xFF);
 581 }
 582
 583 void InitGameEngine_MM()
 584 {
 585   int i, x, y;
 586
 587   BEGIN_NO_HEADLESS
 588   {
 589     /* initialize laser bitmap to current playfield (screen) size */
 590     ReCreateBitmap(&laser_bitmap, drawto->width, drawto->height);
 591     ClearRectangle(laser_bitmap, 0, 0, drawto->width, drawto->height);
 592   }
 593   END_NO_HEADLESS
 594
 595   /* set global game control values */
 596   game_mm.num_cycle = 0;
 597   game_mm.num_pacman = 0;
 598
 599   game_mm.score = 0;
 600   game_mm.energy_left = 0;      // later set to "native_mm_level.time"
 601   game_mm.kettles_still_needed =
 602     (native_mm_level.auto_count_kettles ? 0 : native_mm_level.kettles_needed);
 603   game_mm.lights_still_needed = 0;
 604   game_mm.num_keys = 0;
 605
 606   game_mm.level_solved = FALSE;
 607   game_mm.game_over = FALSE;
 608   game_mm.game_over_cause = 0;
 609
 610   game_mm.laser_overload_value = 0;
 611   game_mm.laser_enabled = FALSE;
 612
 613   /* set global laser control values (must be set before "InitLaser()") */
 614   laser.start_edge.x = 0;
 615   laser.start_edge.y = 0;
 616   laser.start_angle = 0;
 617
 618   for (i = 0; i < MAX_NUM_BEAMERS; i++)
 619     laser.beamer[i][0].num = laser.beamer[i][1].num = 0;
 620
 621   laser.overloaded = FALSE;
 622   laser.overload_value = 0;
 623   laser.fuse_off = FALSE;
 624   laser.fuse_x = laser.fuse_y = -1;
 625
 626   laser.dest_element = EL_EMPTY;
 627   laser.wall_mask = 0;
 628
 629   last_LX = 0;
 630   last_LY = 0;
 631   last_hit_mask = 0;
 632
 633   hold_x = -1;
 634   hold_y = -1;
 635
 636   pacman_nr = -1;
 637
 638   CT = Ct = 0;
 639
 640   rotate_delay = 0;
 641   pacman_delay = 0;
 642   energy_delay = 0;
 643   overload_delay = 0;
 644
 645   ClickElement(-1, -1, -1);
 646
 647   for (x = 0; x < lev_fieldx; x++)
 648   {
 649     for (y = 0; y < lev_fieldy; y++)
 650     {
 651       Feld[x][y] = Ur[x][y];
 652       Hit[x][y] = Box[x][y] = 0;
 653       Angle[x][y] = 0;
 654       MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
 655       Store[x][y] = Store2[x][y] = 0;
 656       Frame[x][y] = 0;
 657       Stop[x][y] = FALSE;
 658
 659       InitField(x, y, TRUE);
 660     }
 661   }
 662
 663 #if 0
 664   CloseDoor(DOOR_CLOSE_1);
 665 #endif
 666
 667   DrawLevel_MM();
 668 }
 669
 670 void InitGameActions_MM()
 671 {
 672   int num_init_game_frames = INIT_GAME_ACTIONS_DELAY;
 673   int cycle_steps_done = 0;
 674   int i;
 675
 676   InitLaser();
 677
 678 #if 0
 679   /* copy default game door content to main double buffer */
 680   BlitBitmap(pix[PIX_DOOR], drawto,
 681              DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
 682 #endif
 683
 684 #if 0
 685   DrawText(DX_LEVEL, DY_LEVEL,
 686            int2str(level_nr, 2), FONT_TEXT_2);
 687   DrawText(DX_KETTLES, DY_KETTLES,
 688            int2str(game_mm.kettles_still_needed, 3), FONT_TEXT_2);
 689   DrawText(DX_SCORE, DY_SCORE,
 690            int2str(game_mm.score, 4), FONT_TEXT_2);
 691 #endif
 692
 693 #if 0
 694   UnmapGameButtons();
 695   MapGameButtons();
 696 #endif
 697
 698 #if 0
 699   /* copy actual game door content to door double buffer for OpenDoor() */
 700   BlitBitmap(drawto, pix[PIX_DB_DOOR],
 701              DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
 702 #endif
 703
 704 #if 0
 705   OpenDoor(DOOR_OPEN_ALL);
 706 #endif
 707
 708   for (i = 0; i <= num_init_game_frames; i++)
 709   {
 710     if (i == num_init_game_frames)
 711       StopSound_MM(SND_MM_GAME_LEVELTIME_CHARGING);
 712     else if (setup.sound_loops)
 713       PlaySoundLoop_MM(SND_MM_GAME_LEVELTIME_CHARGING);
 714     else
 715       PlaySound_MM(SND_MM_GAME_LEVELTIME_CHARGING);
 716
 717     game_mm.energy_left = native_mm_level.time * i / num_init_game_frames;
 718
 719     UpdateAndDisplayGameControlValues();
 720
 721     while (cycle_steps_done < NUM_INIT_CYCLE_STEPS * i / num_init_game_frames)
 722     {
 723       InitCycleElements_RotateSingleStep();
 724
 725       cycle_steps_done++;
 726     }
 727
 728     BackToFront();
 729
 730     ColorCycling();
 731
 732 #ifdef DEBUG
 733     if (setup.quick_doors)
 734       continue;
 735 #endif
 736   }
 737
 738 #if 0
 739   if (setup.sound_music && num_bg_loops)
 740     PlayMusic(level_nr % num_bg_loops);
 741 #endif
 742
 743   ScanLaser();
 744
 745   if (game_mm.kettles_still_needed == 0)
 746     CheckExitMM();
 747
 748   SetTileCursorXY(laser.start_edge.x, laser.start_edge.y);
 749   SetTileCursorActive(TRUE);
 750 }
 751
 752 void AddLaserEdge(int lx, int ly)
 753 {
 754   if (lx < -2 || ly < -2 || lx >= SXSIZE + 2 || ly >= SYSIZE + 2)
 755   {
 756     Error(ERR_WARN, "AddLaserEdge: out of bounds: %d, %d", lx, ly);
 757
 758     return;
 759   }
 760
 761   laser.edge[laser.num_edges].x = SX + 2 + lx;
 762   laser.edge[laser.num_edges].y = SY + 2 + ly;
 763   laser.num_edges++;
 764
 765   laser.redraw = TRUE;
 766 }
 767
 768 void AddDamagedField(int ex, int ey)
 769 {
 770   laser.damage[laser.num_damages].is_mirror = FALSE;
 771   laser.damage[laser.num_damages].angle = laser.current_angle;
 772   laser.damage[laser.num_damages].edge = laser.num_edges;
 773   laser.damage[laser.num_damages].x = ex;
 774   laser.damage[laser.num_damages].y = ey;
 775   laser.num_damages++;
 776 }
 777
 778 boolean StepBehind()
 779 {
 780   if (laser.num_edges)
 781   {
 782     int x = LX - XS;
 783     int y = LY - YS;
 784     int last_x = laser.edge[laser.num_edges - 1].x - SX - 2;
 785     int last_y = laser.edge[laser.num_edges - 1].y - SY - 2;
 786
 787     return ((x - last_x) * XS < 0 || (y - last_y) * YS < 0);
 788   }
 789
 790   return FALSE;
 791 }
 792
 793 static int getMaskFromElement(int element)
 794 {
 795   if (IS_GRID(element))
 796     return IMG_MM_MASK_GRID_1 + get_element_phase(element);
 797   else if (IS_MCDUFFIN(element))
 798     return IMG_MM_MASK_MCDUFFIN_RIGHT + get_element_phase(element);
 799   else if (IS_RECTANGLE(element) || IS_DF_GRID(element))
 800     return IMG_MM_MASK_RECTANGLE;
 801   else
 802     return IMG_MM_MASK_CIRCLE;
 803 }
 804
 805 int ScanPixel()
 806 {
 807   int hit_mask = 0;
 808
 809 #if 0
 810   printf("ScanPixel: start scanning at (%d, %d) [%d, %d] [%d, %d]\n",
 811          LX, LY, LX / TILEX, LY / TILEY, LX % TILEX, LY % TILEY);
 812 #endif
 813
 814   /* follow laser beam until it hits something (at least the screen border) */
 815   while (hit_mask == HIT_MASK_NO_HIT)
 816   {
 817     int i;
 818
 819 #if 0
 820     /* for safety */
 821     if (SX + LX < REAL_SX || SX + LX >= REAL_SX + FULL_SXSIZE ||
 822         SY + LY < REAL_SY || SY + LY >= REAL_SY + FULL_SYSIZE)
 823     {
 824       printf("ScanPixel: touched screen border!\n");
 825
 826       return HIT_MASK_ALL;
 827     }
 828 #endif
 829
 830     for (i = 0; i < 4; i++)
 831     {
 832       int px = LX + (i % 2) * 2;
 833       int py = LY + (i / 2) * 2;
 834       int dx = px % TILEX;
 835       int dy = py % TILEY;
 836       int lx = (px + TILEX) / TILEX - 1;  /* ...+TILEX...-1 to get correct */
 837       int ly = (py + TILEY) / TILEY - 1;  /* negative values!              */
 838       Pixel pixel;
 839
 840       if (IN_LEV_FIELD(lx, ly))
 841       {
 842         int element = Feld[lx][ly];
 843
 844         if (element == EL_EMPTY || element == EL_EXPLODING_TRANSP)
 845         {
 846           pixel = 0;
 847         }
 848         else if (IS_WALL(element) || IS_WALL_CHANGING(element))
 849         {
 850           int pos = dy / MINI_TILEY * 2 + dx / MINI_TILEX;
 851
 852           pixel = ((element & (1 << pos)) ? 1 : 0);
 853         }
 854         else
 855         {
 856           int pos = getMaskFromElement(element) - IMG_MM_MASK_MCDUFFIN_RIGHT;
 857
 858           pixel = (mm_masks[pos][dy / 2][dx / 2] == 'X' ? 1 : 0);
 859         }
 860       }
 861       else
 862       {
 863         pixel = (SX + px < REAL_SX || SX + px >= REAL_SX + FULL_SXSIZE ||
 864                  SY + py < REAL_SY || SY + py >= REAL_SY + FULL_SYSIZE);
 865       }
 866
 867       if ((Sign[laser.current_angle] & (1 << i)) && pixel)
 868         hit_mask |= (1 << i);
 869     }
 870
 871     if (hit_mask == HIT_MASK_NO_HIT)
 872     {
 873       /* hit nothing -- go on with another step */
 874       LX += XS;
 875       LY += YS;
 876     }
 877   }
 878
 879   return hit_mask;
 880 }
 881
 882 void ScanLaser()
 883 {
 884   int element;
 885   int end = 0, rf = laser.num_edges;
 886
 887   /* do not scan laser again after the game was lost for whatever reason */
 888   if (game_mm.game_over)
 889     return;
 890
 891   laser.overloaded = FALSE;
 892   laser.stops_inside_element = FALSE;
 893
 894   DrawLaser(0, DL_LASER_ENABLED);
 895
 896 #if 0
 897   printf("Start scanning with LX == %d, LY == %d, XS == %d, YS == %d\n",
 898          LX, LY, XS, YS);
 899 #endif
 900
 901   while (1)
 902   {
 903     int hit_mask;
 904
 905     if (laser.num_edges > MAX_LASER_LEN || laser.num_damages > MAX_LASER_LEN)
 906     {
 907       end = 1;
 908       laser.overloaded = TRUE;
 909
 910       break;
 911     }
 912
 913     hit_mask = ScanPixel();
 914
 915 #if 0
 916     printf("Hit something at LX == %d, LY == %d, XS == %d, YS == %d\n",
 917            LX, LY, XS, YS);
 918 #endif
 919
 920     /* hit something -- check out what it was */
 921     ELX = (LX + XS) / TILEX;
 922     ELY = (LY + YS) / TILEY;
 923
 924 #if 0
 925     printf("hit_mask (1) == '%x' (%d, %d) (%d, %d)\n",
 926            hit_mask, LX, LY, ELX, ELY);
 927 #endif
 928
 929     if (!IN_LEV_FIELD(ELX, ELY) || !IN_PIX_FIELD(LX, LY))
 930     {
 931       element = EL_EMPTY;
 932       laser.dest_element = element;
 933
 934       break;
 935     }
 936
 937     if (hit_mask == (HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT))
 938     {
 939       /* we have hit the top-right and bottom-left element --
 940          choose the bottom-left one */
 941       /* !!! THIS CAN BE DONE MORE INTELLIGENTLY, FOR EXAMPLE, IF ONE
 942          ELEMENT WAS STEEL AND THE OTHER ONE WAS ICE => ALWAYS CHOOSE
 943          THE ICE AND MELT IT AWAY INSTEAD OF OVERLOADING LASER !!! */
 944       ELX = (LX - 2) / TILEX;
 945       ELY = (LY + 2) / TILEY;
 946     }
 947
 948     if (hit_mask == (HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT))
 949     {
 950       /* we have hit the top-left and bottom-right element --
 951          choose the top-left one */
 952       /* !!! SEE ABOVE !!! */
 953       ELX = (LX - 2) / TILEX;
 954       ELY = (LY - 2) / TILEY;
 955     }
 956
 957 #if 0
 958     printf("hit_mask (2) == '%x' (%d, %d) (%d, %d)\n",
 959            hit_mask, LX, LY, ELX, ELY);
 960 #endif
 961
 962     element = Feld[ELX][ELY];
 963     laser.dest_element = element;
 964
 965 #if 0
 966     printf("Hit element %d at (%d, %d) [%d, %d] [%d, %d] [%d]\n",
 967            element, ELX, ELY,
 968            LX, LY,
 969            LX % TILEX, LY % TILEY,
 970            hit_mask);
 971 #endif
 972
 973 #if 0
 974     if (!IN_LEV_FIELD(ELX, ELY))
 975       printf("WARNING! (1) %d, %d (%d)\n", ELX, ELY, element);
 976 #endif
 977
 978     if (element == EL_EMPTY)
 979     {
 980       if (!HitOnlyAnEdge(element, hit_mask))
 981         break;
 982     }
 983     else if (element == EL_FUSE_ON)
 984     {
 985       if (HitPolarizer(element, hit_mask))
 986         break;
 987     }
 988     else if (IS_GRID(element) || IS_DF_GRID(element))
 989     {
 990       if (HitPolarizer(element, hit_mask))
 991         break;
 992     }
 993     else if (element == EL_BLOCK_STONE || element == EL_BLOCK_WOOD ||
 994              element == EL_GATE_STONE || element == EL_GATE_WOOD)
 995     {
 996       if (HitBlock(element, hit_mask))
 997       {
 998         rf = 1;
 999
1000         break;
1001       }
1002     }
1003     else if (IS_MCDUFFIN(element))
1004     {
1005       if (HitLaserSource(element, hit_mask))
1006         break;
1007     }
1008     else if ((element >= EL_EXIT_CLOSED && element <= EL_EXIT_OPEN) ||
1009              IS_RECEIVER(element))
1010     {
1011       if (HitLaserDestination(element, hit_mask))
1012         break;
1013     }
1014     else if (IS_WALL(element))
1015     {
1016       if (IS_WALL_STEEL(element) || IS_DF_WALL_STEEL(element))
1017       {
1018         if (HitReflectingWalls(element, hit_mask))
1019           break;
1020       }
1021       else
1022       {
1023         if (HitAbsorbingWalls(element, hit_mask))
1024           break;
1025       }
1026     }
1027     else
1028     {
1029       if (HitElement(element, hit_mask))
1030         break;
1031     }
1032
1033     if (rf)
1034       DrawLaser(rf - 1, DL_LASER_ENABLED);
1035     rf = laser.num_edges;
1036   }
1037
1038 #if 0
1039   if (laser.dest_element != Feld[ELX][ELY])
1040   {
1041     printf("ALARM: laser.dest_element == %d, Feld[ELX][ELY] == %d\n",
1042            laser.dest_element, Feld[ELX][ELY]);
1043   }
1044 #endif
1045
1046   if (!end && !laser.stops_inside_element && !StepBehind())
1047   {
1048 #if 0
1049     printf("ScanLaser: Go one step back\n");
1050 #endif
1051
1052     LX -= XS;
1053     LY -= YS;
1054
1055     AddLaserEdge(LX, LY);
1056   }
1057
1058   if (rf)
1059     DrawLaser(rf - 1, DL_LASER_ENABLED);
1060
1061   Ct = CT = FrameCounter;
1062
1063 #if 0
1064     if (!IN_LEV_FIELD(ELX, ELY))
1065       printf("WARNING! (2) %d, %d\n", ELX, ELY);
1066 #endif
1067 }
1068
1069 void DrawLaserExt(int start_edge, int num_edges, int mode)
1070 {
1071   int element;
1072   int elx, ely;
1073
1074 #if 0
1075   printf("DrawLaserExt: start_edge, num_edges, mode == %d, %d, %d\n",
1076          start_edge, num_edges, mode);
1077 #endif
1078
1079   if (start_edge < 0)
1080   {
1081     Error(ERR_WARN, "DrawLaserExt: start_edge < 0");
1082
1083     return;
1084   }
1085
1086   if (num_edges < 0)
1087   {
1088     Error(ERR_WARN, "DrawLaserExt: num_edges < 0");
1089
1090     return;
1091   }
1092
1093 #if 0
1094   if (mode == DL_LASER_DISABLED)
1095   {
1096     printf("DrawLaser: Delete laser from edge %d\n", start_edge);
1097   }
1098 #endif
1099
1100   /* now draw the laser to the backbuffer and (if enabled) to the screen */
1101   DrawLaserLines(&laser.edge[start_edge], num_edges, mode);
1102
1103   redraw_mask |= REDRAW_FIELD;
1104
1105   if (mode == DL_LASER_ENABLED)
1106     return;
1107
1108   /* after the laser was deleted, the "damaged" graphics must be restored */
1109   if (laser.num_damages)
1110   {
1111     int damage_start = 0;
1112     int i;
1113
1114     /* determine the starting edge, from which graphics need to be restored */
1115     if (start_edge > 0)
1116     {
1117       for (i = 0; i < laser.num_damages; i++)
1118       {
1119         if (laser.damage[i].edge == start_edge + 1)
1120         {
1121           damage_start = i;
1122
1123           break;
1124         }
1125       }
1126     }
1127
1128     /* restore graphics from this starting edge to the end of damage list */
1129     for (i = damage_start; i < laser.num_damages; i++)
1130     {
1131       int lx = laser.damage[i].x;
1132       int ly = laser.damage[i].y;
1133       int element = Feld[lx][ly];
1134
1135       if (Hit[lx][ly] == laser.damage[i].edge)
1136         if (!((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1137                i == damage_start))
1138           Hit[lx][ly] = 0;
1139       if (Box[lx][ly] == laser.damage[i].edge)
1140         Box[lx][ly] = 0;
1141
1142       if (IS_DRAWABLE(element))
1143         DrawField_MM(lx, ly);
1144     }
1145
1146     elx = laser.damage[damage_start].x;
1147     ely = laser.damage[damage_start].y;
1148     element = Feld[elx][ely];
1149
1150 #if 0
1151     if (IS_BEAMER(element))
1152     {
1153       int i;
1154
1155       for (i = 0; i < laser.num_beamers; i++)
1156         printf("-> %d\n", laser.beamer_edge[i]);
1157       printf("DrawLaserExt: IS_BEAMER: [%d]: Hit[%d][%d] == %d [%d]\n",
1158              mode, elx, ely, Hit[elx][ely], start_edge);
1159       printf("DrawLaserExt: IS_BEAMER: %d / %d\n",
1160              get_element_angle(element), laser.damage[damage_start].angle);
1161     }
1162 #endif
1163
1164     if ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1165         laser.num_beamers > 0 &&
1166         start_edge == laser.beamer_edge[laser.num_beamers - 1])
1167     {
1168       /* element is outgoing beamer */
1169       laser.num_damages = damage_start + 1;
1170
1171       if (IS_BEAMER(element))
1172         laser.current_angle = get_element_angle(element);
1173     }
1174     else
1175     {
1176       /* element is incoming beamer or other element */
1177       laser.num_damages = damage_start;
1178       laser.current_angle = laser.damage[laser.num_damages].angle;
1179     }
1180   }
1181   else
1182   {
1183     /* no damages but McDuffin himself (who needs to be redrawn anyway) */
1184
1185     elx = laser.start_edge.x;
1186     ely = laser.start_edge.y;
1187     element = Feld[elx][ely];
1188   }
1189
1190   laser.num_edges = start_edge + 1;
1191   if (start_edge == 0)
1192     laser.current_angle = laser.start_angle;
1193
1194   LX = laser.edge[start_edge].x - (SX + 2);
1195   LY = laser.edge[start_edge].y - (SY + 2);
1196   XS = 2 * Step[laser.current_angle].x;
1197   YS = 2 * Step[laser.current_angle].y;
1198
1199 #if 0
1200   printf("DrawLaser: Set (LX, LY) to (%d, %d) [%d]\n",
1201          LX, LY, element);
1202 #endif
1203
1204   if (start_edge > 0)
1205   {
1206     if (IS_BEAMER(element) ||
1207         IS_FIBRE_OPTIC(element) ||
1208         IS_PACMAN(element) ||
1209         IS_POLAR(element) ||
1210         IS_POLAR_CROSS(element) ||
1211         element == EL_FUSE_ON)
1212     {
1213       int step_size;
1214
1215 #if 0
1216       printf("element == %d\n", element);
1217 #endif
1218
1219       if (IS_22_5_ANGLE(laser.current_angle))   /* neither 90° nor 45° angle */
1220         step_size = ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) ? 4 : 3);
1221       else
1222         step_size = 8;
1223
1224       if (IS_POLAR(element) || IS_POLAR_CROSS(element) ||
1225           ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1226            (laser.num_beamers == 0 ||
1227             start_edge != laser.beamer_edge[laser.num_beamers - 1])))
1228       {
1229         /* element is incoming beamer or other element */
1230         step_size = -step_size;
1231         laser.num_edges--;
1232       }
1233
1234 #if 0
1235       if (IS_BEAMER(element))
1236       {
1237         printf("start_edge == %d, laser.beamer_edge == %d\n",
1238                start_edge, laser.beamer_edge);
1239       }
1240 #endif
1241
1242       LX += step_size * XS;
1243       LY += step_size * YS;
1244     }
1245     else if (element != EL_EMPTY)
1246     {
1247       LX -= 3 * XS;
1248       LY -= 3 * YS;
1249       laser.num_edges--;
1250     }
1251   }
1252
1253 #if 0
1254   printf("DrawLaser: Finally: (LX, LY) to (%d, %d) [%d]\n",
1255          LX, LY, element);
1256 #endif
1257 }
1258
1259 void DrawLaser(int start_edge, int mode)
1260 {
1261   if (laser.num_edges - start_edge < 0)
1262   {
1263     Error(ERR_WARN, "DrawLaser: laser.num_edges - start_edge < 0");
1264
1265     return;
1266   }
1267
1268   /* check if laser is interrupted by beamer element */
1269   if (laser.num_beamers > 0 &&
1270       start_edge < laser.beamer_edge[laser.num_beamers - 1])
1271   {
1272     if (mode == DL_LASER_ENABLED)
1273     {
1274       int i;
1275       int tmp_start_edge = start_edge;
1276
1277       /* draw laser segments forward from the start to the last beamer */
1278       for (i = 0; i < laser.num_beamers; i++)
1279       {
1280         int tmp_num_edges = laser.beamer_edge[i] - tmp_start_edge;
1281
1282         if (tmp_num_edges <= 0)
1283           continue;
1284
1285 #if 0
1286         printf("DrawLaser: DL_LASER_ENABLED: i==%d: %d, %d\n",
1287                i, laser.beamer_edge[i], tmp_start_edge);
1288 #endif
1289
1290         DrawLaserExt(tmp_start_edge, tmp_num_edges, DL_LASER_ENABLED);
1291
1292         tmp_start_edge = laser.beamer_edge[i];
1293       }
1294
1295       /* draw last segment from last beamer to the end */
1296       DrawLaserExt(tmp_start_edge, laser.num_edges - tmp_start_edge,
1297                    DL_LASER_ENABLED);
1298     }
1299     else
1300     {
1301       int i;
1302       int last_num_edges = laser.num_edges;
1303       int num_beamers = laser.num_beamers;
1304
1305       /* delete laser segments backward from the end to the first beamer */
1306       for (i = num_beamers - 1; i >= 0; i--)
1307       {
1308         int tmp_num_edges = last_num_edges - laser.beamer_edge[i];
1309
1310         if (laser.beamer_edge[i] - start_edge <= 0)
1311           break;
1312
1313         DrawLaserExt(laser.beamer_edge[i], tmp_num_edges, DL_LASER_DISABLED);
1314
1315         last_num_edges = laser.beamer_edge[i];
1316         laser.num_beamers--;
1317       }
1318
1319 #if 0
1320       if (last_num_edges - start_edge <= 0)
1321         printf("DrawLaser: DL_LASER_DISABLED: %d, %d\n",
1322                last_num_edges, start_edge);
1323 #endif
1324
1325       // special case when rotating first beamer: delete laser edge on beamer
1326       // (but do not start scanning on previous edge to prevent mirror sound)
1327       if (last_num_edges - start_edge == 1 && start_edge > 0)
1328         DrawLaserLines(&laser.edge[start_edge - 1], 2, DL_LASER_DISABLED);
1329
1330       /* delete first segment from start to the first beamer */
1331       DrawLaserExt(start_edge, last_num_edges - start_edge, DL_LASER_DISABLED);
1332     }
1333   }
1334   else
1335   {
1336     DrawLaserExt(start_edge, laser.num_edges - start_edge, mode);
1337   }
1338
1339   game_mm.laser_enabled = mode;
1340 }
1341
1342 void DrawLaser_MM()
1343 {
1344   DrawLaser(0, game_mm.laser_enabled);
1345 }
1346
1347 boolean HitElement(int element, int hit_mask)
1348 {
1349   if (HitOnlyAnEdge(element, hit_mask))
1350     return FALSE;
1351
1352   if (IS_MOVING(ELX, ELY) || IS_BLOCKED(ELX, ELY))
1353     element = MovingOrBlocked2Element_MM(ELX, ELY);
1354
1355 #if 0
1356   printf("HitElement (1): element == %d\n", element);
1357 #endif
1358
1359 #if 0
1360   if ((ELX * TILEX + 14 - LX) * YS == (ELY * TILEY + 14 - LY) * XS)
1361     printf("HitElement (%d): EXACT MATCH @ (%d, %d)\n", element, ELX, ELY);
1362   else
1363     printf("HitElement (%d): FUZZY MATCH @ (%d, %d)\n", element, ELX, ELY);
1364 #endif
1365
1366   AddDamagedField(ELX, ELY);
1367
1368   /* this is more precise: check if laser would go through the center */
1369   if ((ELX * TILEX + 14 - LX) * YS != (ELY * TILEY + 14 - LY) * XS)
1370   {
1371     /* skip the whole element before continuing the scan */
1372     do
1373     {
1374       LX += XS;
1375       LY += YS;
1376     }
1377     while (ELX == LX/TILEX && ELY == LY/TILEY && LX > 0 && LY > 0);
1378
1379     if (LX/TILEX > ELX || LY/TILEY > ELY)
1380     {
1381       /* skipping scan positions to the right and down skips one scan
1382          position too much, because this is only the top left scan position
1383          of totally four scan positions (plus one to the right, one to the
1384          bottom and one to the bottom right) */
1385
1386       LX -= XS;
1387       LY -= YS;
1388     }
1389
1390     return FALSE;
1391   }
1392
1393 #if 0
1394   printf("HitElement (2): element == %d\n", element);
1395 #endif
1396
1397   if (LX + 5 * XS < 0 ||
1398       LY + 5 * YS < 0)
1399   {
1400     LX += 2 * XS;
1401     LY += 2 * YS;
1402
1403     return FALSE;
1404   }
1405
1406 #if 0
1407   printf("HitElement (3): element == %d\n", element);
1408 #endif
1409
1410   if (IS_POLAR(element) &&
1411       ((element - EL_POLAR_START) % 2 ||
1412        (element - EL_POLAR_START) / 2 != laser.current_angle % 8))
1413   {
1414     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1415
1416     laser.num_damages--;
1417
1418     return TRUE;
1419   }
1420
1421   if (IS_POLAR_CROSS(element) &&
1422       (element - EL_POLAR_CROSS_START) != laser.current_angle % 4)
1423   {
1424     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1425
1426     laser.num_damages--;
1427
1428     return TRUE;
1429   }
1430
1431   if (!IS_BEAMER(element) &&
1432       !IS_FIBRE_OPTIC(element) &&
1433       !IS_GRID_WOOD(element) &&
1434       element != EL_FUEL_EMPTY)
1435   {
1436 #if 0
1437     if ((ELX * TILEX + 14 - LX) * YS == (ELY * TILEY + 14 - LY) * XS)
1438       printf("EXACT MATCH @ (%d, %d)\n", ELX, ELY);
1439     else
1440       printf("FUZZY MATCH @ (%d, %d)\n", ELX, ELY);
1441 #endif
1442
1443     LX = ELX * TILEX + 14;
1444     LY = ELY * TILEY + 14;
1445
1446     AddLaserEdge(LX, LY);
1447   }
1448
1449   if (IS_MIRROR(element) ||
1450       IS_MIRROR_FIXED(element) ||
1451       IS_POLAR(element) ||
1452       IS_POLAR_CROSS(element) ||
1453       IS_DF_MIRROR(element) ||
1454       IS_DF_MIRROR_AUTO(element) ||
1455       element == EL_PRISM ||
1456       element == EL_REFRACTOR)
1457   {
1458     int current_angle = laser.current_angle;
1459     int step_size;
1460
1461     laser.num_damages--;
1462
1463     AddDamagedField(ELX, ELY);
1464
1465     laser.damage[laser.num_damages - 1].is_mirror = TRUE;
1466
1467     if (!Hit[ELX][ELY])
1468       Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1469
1470     if (IS_MIRROR(element) ||
1471         IS_MIRROR_FIXED(element) ||
1472         IS_DF_MIRROR(element) ||
1473         IS_DF_MIRROR_AUTO(element))
1474       laser.current_angle = get_mirrored_angle(laser.current_angle,
1475                                                get_element_angle(element));
1476
1477     if (element == EL_PRISM || element == EL_REFRACTOR)
1478       laser.current_angle = RND(16);
1479
1480     XS = 2 * Step[laser.current_angle].x;
1481     YS = 2 * Step[laser.current_angle].y;
1482
1483     if (!IS_22_5_ANGLE(laser.current_angle))    /* 90° or 45° angle */
1484       step_size = 8;
1485     else
1486       step_size = 4;
1487
1488     LX += step_size * XS;
1489     LY += step_size * YS;
1490
1491 #if 0
1492     /* draw sparkles on mirror */
1493     if ((IS_MIRROR(element) || IS_MIRROR_FIXED(element)) &&
1494         current_angle != laser.current_angle)
1495     {
1496       MoveSprite(vp, &Pfeil[2], 4 + 16 * ELX, 5 + 16 * ELY + 1);
1497     }
1498 #endif
1499
1500     if ((!IS_POLAR(element) && !IS_POLAR_CROSS(element)) &&
1501         current_angle != laser.current_angle)
1502       PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1503
1504     laser.overloaded =
1505       (get_opposite_angle(laser.current_angle) ==
1506        laser.damage[laser.num_damages - 1].angle ? TRUE : FALSE);
1507
1508     return (laser.overloaded ? TRUE : FALSE);
1509   }
1510
1511   if (element == EL_FUEL_FULL)
1512   {
1513     laser.stops_inside_element = TRUE;
1514
1515     return TRUE;
1516   }
1517
1518   if (element == EL_BOMB || element == EL_MINE)
1519   {
1520     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1521
1522     if (element == EL_MINE)
1523       laser.overloaded = TRUE;
1524   }
1525
1526   if (element == EL_KETTLE ||
1527       element == EL_CELL ||
1528       element == EL_KEY ||
1529       element == EL_LIGHTBALL ||
1530       element == EL_PACMAN ||
1531       IS_PACMAN(element))
1532   {
1533     if (!IS_PACMAN(element))
1534       Bang_MM(ELX, ELY);
1535
1536     if (element == EL_PACMAN)
1537       Bang_MM(ELX, ELY);
1538
1539     if (element == EL_KETTLE || element == EL_CELL)
1540     {
1541       if (game_mm.kettles_still_needed > 0)
1542         game_mm.kettles_still_needed--;
1543
1544       if (game_mm.kettles_still_needed == 0)
1545       {
1546         CheckExitMM();
1547
1548         DrawLaser(0, DL_LASER_ENABLED);
1549       }
1550     }
1551     else if (element == EL_KEY)
1552     {
1553       game_mm.num_keys++;
1554     }
1555     else if (IS_PACMAN(element))
1556     {
1557       DeletePacMan(ELX, ELY);
1558     }
1559
1560     RaiseScoreElement_MM(element);
1561
1562     return FALSE;
1563   }
1564
1565   if (element == EL_LIGHTBULB_OFF || element == EL_LIGHTBULB_ON)
1566   {
1567     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1568
1569     DrawLaser(0, DL_LASER_ENABLED);
1570
1571     if (Feld[ELX][ELY] == EL_LIGHTBULB_OFF)
1572     {
1573       Feld[ELX][ELY] = EL_LIGHTBULB_ON;
1574       game_mm.lights_still_needed--;
1575     }
1576     else
1577     {
1578       Feld[ELX][ELY] = EL_LIGHTBULB_OFF;
1579       game_mm.lights_still_needed++;
1580     }
1581
1582     DrawField_MM(ELX, ELY);
1583     DrawLaser(0, DL_LASER_ENABLED);
1584
1585     /*
1586     BackToFront();
1587     */
1588     laser.stops_inside_element = TRUE;
1589
1590     return TRUE;
1591   }
1592
1593 #if 0
1594   printf("HitElement (4): element == %d\n", element);
1595 #endif
1596
1597   if ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1598       laser.num_beamers < MAX_NUM_BEAMERS &&
1599       laser.beamer[BEAMER_NR(element)][1].num)
1600   {
1601     int beamer_angle = get_element_angle(element);
1602     int beamer_nr = BEAMER_NR(element);
1603     int step_size;
1604
1605 #if 0
1606   printf("HitElement (BEAMER): element == %d\n", element);
1607 #endif
1608
1609     laser.num_damages--;
1610
1611     if (IS_FIBRE_OPTIC(element) ||
1612         laser.current_angle == get_opposite_angle(beamer_angle))
1613     {
1614       int pos;
1615
1616       LX = ELX * TILEX + 14;
1617       LY = ELY * TILEY + 14;
1618
1619       AddLaserEdge(LX, LY);
1620       AddDamagedField(ELX, ELY);
1621
1622       laser.damage[laser.num_damages - 1].is_mirror = TRUE;
1623
1624       if (!Hit[ELX][ELY])
1625         Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1626
1627       pos = (ELX == laser.beamer[beamer_nr][0].x &&
1628              ELY == laser.beamer[beamer_nr][0].y ? 1 : 0);
1629       ELX = laser.beamer[beamer_nr][pos].x;
1630       ELY = laser.beamer[beamer_nr][pos].y;
1631       LX = ELX * TILEX + 14;
1632       LY = ELY * TILEY + 14;
1633
1634       if (IS_BEAMER(element))
1635       {
1636         laser.current_angle = get_element_angle(Feld[ELX][ELY]);
1637         XS = 2 * Step[laser.current_angle].x;
1638         YS = 2 * Step[laser.current_angle].y;
1639       }
1640
1641       laser.beamer_edge[laser.num_beamers] = laser.num_edges;
1642
1643       AddLaserEdge(LX, LY);
1644       AddDamagedField(ELX, ELY);
1645
1646       laser.damage[laser.num_damages - 1].is_mirror = TRUE;
1647
1648       if (!Hit[ELX][ELY])
1649         Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1650
1651       if (laser.current_angle == (laser.current_angle >> 1) << 1)
1652         step_size = 8;
1653       else
1654         step_size = 4;
1655
1656       LX += step_size * XS;
1657       LY += step_size * YS;
1658
1659       laser.num_beamers++;
1660
1661       return FALSE;
1662     }
1663   }
1664
1665   return TRUE;
1666 }
1667
1668 boolean HitOnlyAnEdge(int element, int hit_mask)
1669 {
1670   /* check if the laser hit only the edge of an element and, if so, go on */
1671
1672 #if 0
1673   printf("LX, LY, hit_mask == %d, %d, %d\n", LX, LY, hit_mask);
1674 #endif
1675
1676   if ((hit_mask == HIT_MASK_TOPLEFT ||
1677        hit_mask == HIT_MASK_TOPRIGHT ||
1678        hit_mask == HIT_MASK_BOTTOMLEFT ||
1679        hit_mask == HIT_MASK_BOTTOMRIGHT) &&
1680       laser.current_angle % 4)                  /* angle is not 90° */
1681   {
1682     int dx, dy;
1683
1684     if (hit_mask == HIT_MASK_TOPLEFT)
1685     {
1686       dx = -1;
1687       dy = -1;
1688     }
1689     else if (hit_mask == HIT_MASK_TOPRIGHT)
1690     {
1691       dx = +1;
1692       dy = -1;
1693     }
1694     else if (hit_mask == HIT_MASK_BOTTOMLEFT)
1695     {
1696       dx = -1;
1697       dy = +1;
1698     }
1699     else /* (hit_mask == HIT_MASK_BOTTOMRIGHT) */
1700     {
1701       dx = +1;
1702       dy = +1;
1703     }
1704
1705     AddDamagedField((LX + 2 * dx) / TILEX, (LY + 2 * dy) / TILEY);
1706
1707     LX += XS;
1708     LY += YS;
1709
1710 #if 0
1711     printf("[HitOnlyAnEdge() == TRUE]\n");
1712 #endif
1713
1714     return TRUE;
1715   }
1716
1717 #if 0
1718     printf("[HitOnlyAnEdge() == FALSE]\n");
1719 #endif
1720
1721   return FALSE;
1722 }
1723
1724 boolean HitPolarizer(int element, int hit_mask)
1725 {
1726   if (HitOnlyAnEdge(element, hit_mask))
1727     return FALSE;
1728
1729   if (IS_DF_GRID(element))
1730   {
1731     int grid_angle = get_element_angle(element);
1732
1733 #if 0
1734     printf("HitPolarizer: angle: grid == %d, laser == %d\n",
1735            grid_angle, laser.current_angle);
1736 #endif
1737
1738     AddLaserEdge(LX, LY);
1739     AddDamagedField(ELX, ELY);
1740
1741     if (!Hit[ELX][ELY])
1742       Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1743
1744     if (laser.current_angle == grid_angle ||
1745         laser.current_angle == get_opposite_angle(grid_angle))
1746     {
1747       /* skip the whole element before continuing the scan */
1748       do
1749       {
1750         LX += XS;
1751         LY += YS;
1752       }
1753       while (ELX == LX/TILEX && ELY == LY/TILEY && LX > 0 && LY > 0);
1754
1755       if (LX/TILEX > ELX || LY/TILEY > ELY)
1756       {
1757         /* skipping scan positions to the right and down skips one scan
1758            position too much, because this is only the top left scan position
1759            of totally four scan positions (plus one to the right, one to the
1760            bottom and one to the bottom right) */
1761
1762         LX -= XS;
1763         LY -= YS;
1764       }
1765
1766       AddLaserEdge(LX, LY);
1767
1768       LX += XS;
1769       LY += YS;
1770
1771 #if 0
1772       printf("HitPolarizer: LX, LY == %d, %d [%d, %d] [%d, %d]\n",
1773              LX, LY,
1774              LX / TILEX, LY / TILEY,
1775              LX % TILEX, LY % TILEY);
1776 #endif
1777
1778       return FALSE;
1779     }
1780     else if (IS_GRID_STEEL_FIXED(element) || IS_GRID_STEEL_AUTO(element))
1781     {
1782       return HitReflectingWalls(element, hit_mask);
1783     }
1784     else
1785     {
1786       return HitAbsorbingWalls(element, hit_mask);
1787     }
1788   }
1789   else if (IS_GRID_STEEL(element))
1790   {
1791     return HitReflectingWalls(element, hit_mask);
1792   }
1793   else  /* IS_GRID_WOOD */
1794   {
1795     return HitAbsorbingWalls(element, hit_mask);
1796   }
1797
1798   return TRUE;
1799 }
1800
1801 boolean HitBlock(int element, int hit_mask)
1802 {
1803   boolean check = FALSE;
1804
1805   if ((element == EL_GATE_STONE || element == EL_GATE_WOOD) &&
1806       game_mm.num_keys == 0)
1807     check = TRUE;
1808
1809   if (element == EL_BLOCK_STONE || element == EL_BLOCK_WOOD)
1810   {
1811     int i, x, y;
1812     int ex = ELX * TILEX + 14;
1813     int ey = ELY * TILEY + 14;
1814
1815     check = TRUE;
1816
1817     for (i = 1; i < 32; i++)
1818     {
1819       x = LX + i * XS;
1820       y = LY + i * YS;
1821
1822       if ((x == ex || x == ex + 1) && (y == ey || y == ey + 1))
1823         check = FALSE;
1824     }
1825   }
1826
1827   if (check && (element == EL_BLOCK_WOOD || element == EL_GATE_WOOD))
1828     return HitAbsorbingWalls(element, hit_mask);
1829
1830   if (check)
1831   {
1832     AddLaserEdge(LX - XS, LY - YS);
1833     AddDamagedField(ELX, ELY);
1834
1835     if (!Box[ELX][ELY])
1836       Box[ELX][ELY] = laser.num_edges;
1837
1838     return HitReflectingWalls(element, hit_mask);
1839   }
1840
1841   if (element == EL_GATE_STONE || element == EL_GATE_WOOD)
1842   {
1843     int xs = XS / 2, ys = YS / 2;
1844     int hit_mask_diagonal1 = HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT;
1845     int hit_mask_diagonal2 = HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT;
1846
1847     if ((hit_mask & hit_mask_diagonal1) == hit_mask_diagonal1 ||
1848         (hit_mask & hit_mask_diagonal2) == hit_mask_diagonal2)
1849     {
1850       laser.overloaded = (element == EL_GATE_STONE);
1851
1852       return TRUE;
1853     }
1854
1855     if (ABS(xs) == 1 && ABS(ys) == 1 &&
1856         (hit_mask == HIT_MASK_TOP ||
1857          hit_mask == HIT_MASK_LEFT ||
1858          hit_mask == HIT_MASK_RIGHT ||
1859          hit_mask == HIT_MASK_BOTTOM))
1860       AddDamagedField(ELX - xs * (hit_mask == HIT_MASK_TOP ||
1861                                   hit_mask == HIT_MASK_BOTTOM),
1862                       ELY - ys * (hit_mask == HIT_MASK_LEFT ||
1863                                   hit_mask == HIT_MASK_RIGHT));
1864     AddLaserEdge(LX, LY);
1865
1866     Bang_MM(ELX, ELY);
1867
1868     game_mm.num_keys--;
1869
1870     if (element == EL_GATE_STONE && Box[ELX][ELY])
1871     {
1872       DrawLaser(Box[ELX][ELY] - 1, DL_LASER_DISABLED);
1873       /*
1874       BackToFront();
1875       */
1876       ScanLaser();
1877
1878       return TRUE;
1879     }
1880
1881     return FALSE;
1882   }
1883
1884   if (element == EL_BLOCK_STONE || element == EL_BLOCK_WOOD)
1885   {
1886     int xs = XS / 2, ys = YS / 2;
1887     int hit_mask_diagonal1 = HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT;
1888     int hit_mask_diagonal2 = HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT;
1889
1890     if ((hit_mask & hit_mask_diagonal1) == hit_mask_diagonal1 ||
1891         (hit_mask & hit_mask_diagonal2) == hit_mask_diagonal2)
1892     {
1893       laser.overloaded = (element == EL_BLOCK_STONE);
1894
1895       return TRUE;
1896     }
1897
1898     if (ABS(xs) == 1 && ABS(ys) == 1 &&
1899         (hit_mask == HIT_MASK_TOP ||
1900          hit_mask == HIT_MASK_LEFT ||
1901          hit_mask == HIT_MASK_RIGHT ||
1902          hit_mask == HIT_MASK_BOTTOM))
1903       AddDamagedField(ELX - xs * (hit_mask == HIT_MASK_TOP ||
1904                                   hit_mask == HIT_MASK_BOTTOM),
1905                       ELY - ys * (hit_mask == HIT_MASK_LEFT ||
1906                                   hit_mask == HIT_MASK_RIGHT));
1907     AddDamagedField(ELX, ELY);
1908
1909     LX = ELX * TILEX + 14;
1910     LY = ELY * TILEY + 14;
1911
1912     AddLaserEdge(LX, LY);
1913
1914     laser.stops_inside_element = TRUE;
1915
1916     return TRUE;
1917   }
1918
1919   return TRUE;
1920 }
1921
1922 boolean HitLaserSource(int element, int hit_mask)
1923 {
1924   if (HitOnlyAnEdge(element, hit_mask))
1925     return FALSE;
1926
1927   PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1928
1929   laser.overloaded = TRUE;
1930
1931   return TRUE;
1932 }
1933
1934 boolean HitLaserDestination(int element, int hit_mask)
1935 {
1936   if (HitOnlyAnEdge(element, hit_mask))
1937     return FALSE;
1938
1939   if (element != EL_EXIT_OPEN &&
1940       !(IS_RECEIVER(element) &&
1941         game_mm.kettles_still_needed == 0 &&
1942         laser.current_angle == get_opposite_angle(get_element_angle(element))))
1943   {
1944     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1945
1946     return TRUE;
1947   }
1948
1949   if (IS_RECEIVER(element) ||
1950       (IS_22_5_ANGLE(laser.current_angle) &&
1951        (ELX != (LX + 6 * XS) / TILEX ||
1952         ELY != (LY + 6 * YS) / TILEY ||
1953         LX + 6 * XS < 0 ||
1954         LY + 6 * YS < 0)))
1955   {
1956     LX -= XS;
1957     LY -= YS;
1958   }
1959   else
1960   {
1961     LX = ELX * TILEX + 14;
1962     LY = ELY * TILEY + 14;
1963
1964     laser.stops_inside_element = TRUE;
1965   }
1966
1967   AddLaserEdge(LX, LY);
1968   AddDamagedField(ELX, ELY);
1969
1970   if (game_mm.lights_still_needed == 0)
1971   {
1972     game_mm.level_solved = TRUE;
1973
1974     SetTileCursorActive(FALSE);
1975   }
1976
1977   return TRUE;
1978 }
1979
1980 boolean HitReflectingWalls(int element, int hit_mask)
1981 {
1982   /* check if laser hits side of a wall with an angle that is not 90° */
1983   if (!IS_90_ANGLE(laser.current_angle) && (hit_mask == HIT_MASK_TOP ||
1984                                             hit_mask == HIT_MASK_LEFT ||
1985                                             hit_mask == HIT_MASK_RIGHT ||
1986                                             hit_mask == HIT_MASK_BOTTOM))
1987   {
1988     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1989
1990     LX -= XS;
1991     LY -= YS;
1992
1993     if (!IS_DF_GRID(element))
1994       AddLaserEdge(LX, LY);
1995
1996     /* check if laser hits wall with an angle of 45° */
1997     if (!IS_22_5_ANGLE(laser.current_angle))
1998     {
1999       if (hit_mask == HIT_MASK_TOP || hit_mask == HIT_MASK_BOTTOM)
2000       {
2001         LX += 2 * XS;
2002         laser.current_angle = get_mirrored_angle(laser.current_angle,
2003                                                  ANG_MIRROR_0);
2004       }
2005       else      /* hit_mask == HIT_MASK_LEFT || hit_mask == HIT_MASK_RIGHT */
2006       {
2007         LY += 2 * YS;
2008         laser.current_angle = get_mirrored_angle(laser.current_angle,
2009                                                  ANG_MIRROR_90);
2010       }
2011
2012       AddLaserEdge(LX, LY);
2013
2014       XS = 2 * Step[laser.current_angle].x;
2015       YS = 2 * Step[laser.current_angle].y;
2016
2017       return FALSE;
2018     }
2019     else if (hit_mask == HIT_MASK_TOP || hit_mask == HIT_MASK_BOTTOM)
2020     {
2021       laser.current_angle = get_mirrored_angle(laser.current_angle,
2022                                                ANG_MIRROR_0);
2023       if (ABS(XS) == 4)
2024       {
2025         LX += 2 * XS;
2026         if (!IS_DF_GRID(element))
2027           AddLaserEdge(LX, LY);
2028       }
2029       else
2030       {
2031         LX += XS;
2032         if (!IS_DF_GRID(element))
2033           AddLaserEdge(LX, LY + YS / 2);
2034
2035         LX += XS;
2036         if (!IS_DF_GRID(element))
2037           AddLaserEdge(LX, LY);
2038       }
2039
2040       YS = 2 * Step[laser.current_angle].y;
2041
2042       return FALSE;
2043     }
2044     else        /* hit_mask == HIT_MASK_LEFT || hit_mask == HIT_MASK_RIGHT */
2045     {
2046       laser.current_angle = get_mirrored_angle(laser.current_angle,
2047                                                ANG_MIRROR_90);
2048       if (ABS(YS) == 4)
2049       {
2050         LY += 2 * YS;
2051         if (!IS_DF_GRID(element))
2052           AddLaserEdge(LX, LY);
2053       }
2054       else
2055       {
2056         LY += YS;
2057         if (!IS_DF_GRID(element))
2058           AddLaserEdge(LX + XS / 2, LY);
2059
2060         LY += YS;
2061         if (!IS_DF_GRID(element))
2062           AddLaserEdge(LX, LY);
2063       }
2064
2065       XS = 2 * Step[laser.current_angle].x;
2066
2067       return FALSE;
2068     }
2069   }
2070
2071   /* reflection at the edge of reflecting DF style wall */
2072   if (IS_DF_WALL_STEEL(element) && IS_22_5_ANGLE(laser.current_angle))
2073   {
2074     if (((laser.current_angle == 1 || laser.current_angle == 3) &&
2075          hit_mask == HIT_MASK_TOPRIGHT) ||
2076         ((laser.current_angle == 5 || laser.current_angle == 7) &&
2077          hit_mask == HIT_MASK_TOPLEFT) ||
2078         ((laser.current_angle == 9 || laser.current_angle == 11) &&
2079          hit_mask == HIT_MASK_BOTTOMLEFT) ||
2080         ((laser.current_angle == 13 || laser.current_angle == 15) &&
2081          hit_mask == HIT_MASK_BOTTOMRIGHT))
2082     {
2083       int mirror_angle =
2084         (hit_mask == HIT_MASK_TOPRIGHT || hit_mask == HIT_MASK_BOTTOMLEFT ?
2085          ANG_MIRROR_135 : ANG_MIRROR_45);
2086
2087       PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
2088
2089       AddDamagedField(ELX, ELY);
2090       AddLaserEdge(LX, LY);
2091
2092       laser.current_angle = get_mirrored_angle(laser.current_angle,
2093                                                mirror_angle);
2094       XS = 8 / -XS;
2095       YS = 8 / -YS;
2096
2097       LX += XS;
2098       LY += YS;
2099
2100       AddLaserEdge(LX, LY);
2101
2102       return FALSE;
2103     }
2104   }
2105
2106   /* reflection inside an edge of reflecting DF style wall */
2107   if (IS_DF_WALL_STEEL(element) && IS_22_5_ANGLE(laser.current_angle))
2108   {
2109     if (((laser.current_angle == 1 || laser.current_angle == 3) &&
2110          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_BOTTOMLEFT)) ||
2111         ((laser.current_angle == 5 || laser.current_angle == 7) &&
2112          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_BOTTOMRIGHT)) ||
2113         ((laser.current_angle == 9 || laser.current_angle == 11) &&
2114          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_TOPRIGHT)) ||
2115         ((laser.current_angle == 13 || laser.current_angle == 15) &&
2116          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_TOPLEFT)))
2117     {
2118       int mirror_angle =
2119         (hit_mask == (HIT_MASK_ALL ^ HIT_MASK_BOTTOMLEFT) ||
2120          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_TOPRIGHT) ?
2121          ANG_MIRROR_135 : ANG_MIRROR_45);
2122
2123       PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
2124
2125       /*
2126       AddDamagedField(ELX, ELY);
2127       */
2128
2129       AddLaserEdge(LX - XS, LY - YS);
2130       AddLaserEdge(LX - XS + (ABS(XS) == 4 ? XS/2 : 0),
2131                    LY - YS + (ABS(YS) == 4 ? YS/2 : 0));
2132
2133       laser.current_angle = get_mirrored_angle(laser.current_angle,
2134                                                mirror_angle);
2135       XS = 8 / -XS;
2136       YS = 8 / -YS;
2137
2138       LX += XS;
2139       LY += YS;
2140
2141       AddLaserEdge(LX, LY);
2142
2143       return FALSE;
2144     }
2145   }
2146
2147   /* check if laser hits DF style wall with an angle of 90° */
2148   if (IS_DF_WALL(element) && IS_90_ANGLE(laser.current_angle))
2149   {
2150     if ((IS_HORIZ_ANGLE(laser.current_angle) &&
2151          (!(hit_mask & HIT_MASK_TOP) || !(hit_mask & HIT_MASK_BOTTOM))) ||
2152         (IS_VERT_ANGLE(laser.current_angle) &&
2153          (!(hit_mask & HIT_MASK_LEFT) || !(hit_mask & HIT_MASK_RIGHT))))
2154     {
2155       /* laser at last step touched nothing or the same side of the wall */
2156       if (LX != last_LX || LY != last_LY || hit_mask == last_hit_mask)
2157       {
2158         AddDamagedField(ELX, ELY);
2159
2160         LX += 8 * XS;
2161         LY += 8 * YS;
2162
2163         last_LX = LX;
2164         last_LY = LY;
2165         last_hit_mask = hit_mask;
2166
2167         return FALSE;
2168       }
2169     }
2170   }
2171
2172   if (!HitOnlyAnEdge(element, hit_mask))
2173   {
2174     laser.overloaded = TRUE;
2175
2176     return TRUE;
2177   }
2178
2179   return FALSE;
2180 }
2181
2182 boolean HitAbsorbingWalls(int element, int hit_mask)
2183 {
2184   if (HitOnlyAnEdge(element, hit_mask))
2185     return FALSE;
2186
2187   if (ABS(XS) == 4 &&
2188       (hit_mask == HIT_MASK_LEFT || hit_mask == HIT_MASK_RIGHT))
2189   {
2190     AddLaserEdge(LX - XS, LY - YS);
2191
2192     LX = LX + XS / 2;
2193     LY = LY + YS;
2194   }
2195
2196   if (ABS(YS) == 4 &&
2197       (hit_mask == HIT_MASK_TOP || hit_mask == HIT_MASK_BOTTOM))
2198   {
2199     AddLaserEdge(LX - XS, LY - YS);
2200
2201     LX = LX + XS;
2202     LY = LY + YS / 2;
2203   }
2204
2205   if (IS_WALL_WOOD(element) ||
2206       IS_DF_WALL_WOOD(element) ||
2207       IS_GRID_WOOD(element) ||
2208       IS_GRID_WOOD_FIXED(element) ||
2209       IS_GRID_WOOD_AUTO(element) ||
2210       element == EL_FUSE_ON ||
2211       element == EL_BLOCK_WOOD ||
2212       element == EL_GATE_WOOD)
2213   {
2214     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
2215
2216     return TRUE;
2217   }
2218
2219   if (IS_WALL_ICE(element))
2220   {
2221     int mask;
2222
2223     mask = (LX + XS) / MINI_TILEX - ELX * 2 + 1;    /* Quadrant (horizontal) */
2224     mask <<= (((LY + YS) / MINI_TILEY - ELY * 2) > 0) * 2;  /* || (vertical) */
2225
2226     /* check if laser hits wall with an angle of 90° */
2227     if (IS_90_ANGLE(laser.current_angle))
2228       mask += mask * (2 + IS_HORIZ_ANGLE(laser.current_angle) * 2);
2229
2230     if (mask == 1 || mask == 2 || mask == 4 || mask == 8)
2231     {
2232       int i;
2233
2234       for (i = 0; i < 4; i++)
2235       {
2236         if (mask == (1 << i) && (XS > 0) == (i % 2) && (YS > 0) == (i / 2))
2237           mask = 15 - (8 >> i);
2238         else if (ABS(XS) == 4 &&
2239                  mask == (1 << i) &&
2240                  (XS > 0) == (i % 2) &&
2241                  (YS < 0) == (i / 2))
2242           mask = 3 + (i / 2) * 9;
2243         else if (ABS(YS) == 4 &&
2244                  mask == (1 << i) &&
2245                  (XS < 0) == (i % 2) &&
2246                  (YS > 0) == (i / 2))
2247           mask = 5 + (i % 2) * 5;
2248       }
2249     }
2250
2251     laser.wall_mask = mask;
2252   }
2253   else if (IS_WALL_AMOEBA(element))
2254   {
2255     int elx = (LX - 2 * XS) / TILEX;
2256     int ely = (LY - 2 * YS) / TILEY;
2257     int element2 = Feld[elx][ely];
2258     int mask;
2259
2260     if (element2 != EL_EMPTY && !IS_WALL_AMOEBA(element2))
2261     {
2262       laser.dest_element = EL_EMPTY;
2263
2264       return TRUE;
2265     }
2266
2267     ELX = elx;
2268     ELY = ely;
2269
2270     mask = (LX - 2 * XS) / 16 - ELX * 2 + 1;
2271     mask <<= ((LY - 2 * YS) / 16 - ELY * 2) * 2;
2272
2273     if (IS_90_ANGLE(laser.current_angle))
2274       mask += mask * (2 + IS_HORIZ_ANGLE(laser.current_angle) * 2);
2275
2276     laser.dest_element = element2 | EL_WALL_AMOEBA;
2277
2278     laser.wall_mask = mask;
2279   }
2280
2281   return TRUE;
2282 }
2283
2284 void OpenExit(int x, int y)
2285 {
2286   int delay = 6;
2287
2288   if (!MovDelay[x][y])          /* next animation frame */
2289     MovDelay[x][y] = 4 * delay;
2290
2291   if (MovDelay[x][y])           /* wait some time before next frame */
2292   {
2293     int phase;
2294
2295     MovDelay[x][y]--;
2296     phase = MovDelay[x][y] / delay;
2297
2298     if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(x, y))
2299       DrawGraphicAnimation_MM(x, y, IMG_MM_EXIT_OPENING, 3 - phase);
2300
2301     if (!MovDelay[x][y])
2302     {
2303       Feld[x][y] = EL_EXIT_OPEN;
2304       DrawField_MM(x, y);
2305     }
2306   }
2307 }
2308
2309 void OpenSurpriseBall(int x, int y)
2310 {
2311   int delay = 2;
2312
2313   if (!MovDelay[x][y])          /* next animation frame */
2314     MovDelay[x][y] = 50 * delay;
2315
2316   if (MovDelay[x][y])           /* wait some time before next frame */
2317   {
2318     MovDelay[x][y]--;
2319
2320     if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(x, y))
2321     {
2322       Bitmap *bitmap;
2323       int graphic = el2gfx(Store[x][y]);
2324       int gx, gy;
2325       int dx = RND(26), dy = RND(26);
2326
2327       getGraphicSource(graphic, 0, &bitmap, &gx, &gy);
2328
2329       BlitBitmap(bitmap, drawto, gx + dx, gy + dy, 6, 6,
2330                  SX + x * TILEX + dx, SY + y * TILEY + dy);
2331
2332       MarkTileDirty(x, y);
2333     }
2334
2335     if (!MovDelay[x][y])
2336     {
2337       Feld[x][y] = Store[x][y];
2338       Store[x][y] = 0;
2339       DrawField_MM(x, y);
2340
2341       ScanLaser();
2342     }
2343   }
2344 }
2345
2346 void MeltIce(int x, int y)
2347 {
2348   int frames = 5;
2349   int delay = 5;
2350
2351   if (!MovDelay[x][y])          /* next animation frame */
2352     MovDelay[x][y] = frames * delay;
2353
2354   if (MovDelay[x][y])           /* wait some time before next frame */
2355   {
2356     int phase;
2357     int wall_mask = Store2[x][y];
2358     int real_element = Feld[x][y] - EL_WALL_CHANGING + EL_WALL_ICE;
2359
2360     MovDelay[x][y]--;
2361     phase = frames - MovDelay[x][y] / delay - 1;
2362
2363     if (!MovDelay[x][y])
2364     {
2365       int i;
2366
2367       Feld[x][y] = real_element & (wall_mask ^ 0xFF);
2368       Store[x][y] = Store2[x][y] = 0;
2369
2370       DrawWalls_MM(x, y, Feld[x][y]);
2371
2372       if (Feld[x][y] == EL_WALL_ICE)
2373         Feld[x][y] = EL_EMPTY;
2374
2375       for (i = (laser.num_damages > 0 ? laser.num_damages - 1 : 0); i >= 0; i--)
2376         if (laser.damage[i].is_mirror)
2377           break;
2378
2379       if (i > 0)
2380         DrawLaser(laser.damage[i].edge - 1, DL_LASER_DISABLED);
2381       else
2382         DrawLaser(0, DL_LASER_DISABLED);
2383
2384       ScanLaser();
2385     }
2386     else if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(x, y))
2387     {
2388       DrawWallsAnimation_MM(x, y, real_element, phase, wall_mask);
2389
2390       laser.redraw = TRUE;
2391     }
2392   }
2393 }
2394
2395 void GrowAmoeba(int x, int y)
2396 {
2397   int frames = 5;
2398   int delay = 1;
2399
2400   if (!MovDelay[x][y])          /* next animation frame */
2401     MovDelay[x][y] = frames * delay;
2402
2403   if (MovDelay[x][y])           /* wait some time before next frame */
2404   {
2405     int phase;
2406     int wall_mask = Store2[x][y];
2407     int real_element = Feld[x][y] - EL_WALL_CHANGING + EL_WALL_AMOEBA;
2408
2409     MovDelay[x][y]--;
2410     phase = MovDelay[x][y] / delay;
2411
2412     if (!MovDelay[x][y])
2413     {
2414       Feld[x][y] = real_element;
2415       Store[x][y] = Store2[x][y] = 0;
2416
2417       DrawWalls_MM(x, y, Feld[x][y]);
2418       DrawLaser(0, DL_LASER_ENABLED);
2419     }
2420     else if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(x, y))
2421     {
2422       DrawWallsAnimation_MM(x, y, real_element, phase, wall_mask);
2423     }
2424   }
2425 }
2426
2427 static void Explode_MM(int x, int y, int phase, int mode)
2428 {
2429   int num_phase = 9, delay = 2;
2430   int last_phase = num_phase * delay;
2431   int half_phase = (num_phase / 2) * delay;
2432
2433   laser.redraw = TRUE;
2434
2435   if (phase == EX_PHASE_START)          /* initialize 'Store[][]' field */
2436   {
2437     int center_element = Feld[x][y];
2438
2439     if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
2440     {
2441       /* put moving element to center field (and let it explode there) */
2442       center_element = MovingOrBlocked2Element_MM(x, y);
2443       RemoveMovingField_MM(x, y);
2444
2445       Feld[x][y] = center_element;
2446     }
2447
2448     if (center_element == EL_BOMB || IS_MCDUFFIN(center_element))
2449       Store[x][y] = center_element;
2450     else
2451       Store[x][y] = EL_EMPTY;
2452
2453     Store2[x][y] = mode;
2454     Feld[x][y] = EL_EXPLODING_OPAQUE;
2455     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
2456     Frame[x][y] = 1;
2457
2458     return;
2459   }
2460
2461   Frame[x][y] = (phase < last_phase ? phase + 1 : 0);
2462
2463   if (phase == half_phase)
2464   {
2465     Feld[x][y] = EL_EXPLODING_TRANSP;
2466
2467     if (x == ELX && y == ELY)
2468       ScanLaser();
2469   }
2470
2471   if (phase == last_phase)
2472   {
2473     if (Store[x][y] == EL_BOMB)
2474     {
2475       DrawLaser(0, DL_LASER_DISABLED);
2476       InitLaser();
2477
2478       Bang_MM(laser.start_edge.x, laser.start_edge.y);
2479       Store[x][y] = EL_EMPTY;
2480
2481       game_mm.game_over = TRUE;
2482       game_mm.game_over_cause = GAME_OVER_BOMB;
2483
2484       SetTileCursorActive(FALSE);
2485
2486       laser.overloaded = FALSE;
2487     }
2488     else if (IS_MCDUFFIN(Store[x][y]))
2489     {
2490       Store[x][y] = EL_EMPTY;
2491     }
2492
2493     Feld[x][y] = Store[x][y];
2494     Store[x][y] = Store2[x][y] = 0;
2495     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
2496
2497     InitField(x, y, FALSE);
2498     DrawField_MM(x, y);
2499   }
2500   else if (!(phase % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2501   {
2502     int graphic = IMG_MM_DEFAULT_EXPLODING;
2503     int graphic_phase = (phase / delay - 1);
2504     Bitmap *bitmap;
2505     int src_x, src_y;
2506
2507     if (Store2[x][y] == EX_KETTLE)
2508     {
2509       if (graphic_phase < 3)
2510       {
2511         graphic = IMG_MM_KETTLE_EXPLODING;
2512       }
2513       else if (graphic_phase < 5)
2514       {
2515         graphic_phase += 3;
2516       }
2517       else
2518       {
2519         graphic = IMG_EMPTY;
2520         graphic_phase = 0;
2521       }
2522     }
2523     else if (Store2[x][y] == EX_SHORT)
2524     {
2525       if (graphic_phase < 4)
2526       {
2527         graphic_phase += 4;
2528       }
2529       else
2530       {
2531         graphic = IMG_EMPTY;
2532         graphic_phase = 0;
2533       }
2534     }
2535
2536     getGraphicSource(graphic, graphic_phase, &bitmap, &src_x, &src_y);
2537
2538     BlitBitmap(bitmap, drawto_field, src_x, src_y, TILEX, TILEY,
2539                FX + x * TILEX, FY + y * TILEY);
2540
2541     MarkTileDirty(x, y);
2542   }
2543 }
2544
2545 static void Bang_MM(int x, int y)
2546 {
2547   int element = Feld[x][y];
2548   int mode = EX_NORMAL;
2549
2550 #if 0
2551   DrawLaser(0, DL_LASER_ENABLED);
2552 #endif
2553
2554   switch(element)
2555   {
2556     case EL_KETTLE:
2557       mode = EX_KETTLE;
2558       break;
2559
2560     case EL_GATE_STONE:
2561     case EL_GATE_WOOD:
2562       mode = EX_SHORT;
2563       break;
2564
2565     default:
2566       mode = EX_NORMAL;
2567       break;
2568   }
2569
2570   if (IS_PACMAN(element))
2571     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2572   else if (element == EL_BOMB || IS_MCDUFFIN(element))
2573     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2574   else if (element == EL_KEY)
2575     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2576   else
2577     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2578
2579   Explode_MM(x, y, EX_PHASE_START, mode);
2580 }
2581
2582 void TurnRound(int x, int y)
2583 {
2584   static struct
2585   {
2586     int x, y;
2587   } move_xy[] =
2588   {
2589     { 0, 0 },
2590     {-1, 0 },
2591     {+1, 0 },
2592     { 0, 0 },
2593     { 0, -1 },
2594     { 0, 0 }, { 0, 0 }, { 0, 0 },
2595     { 0, +1 }
2596   };
2597   static struct
2598   {
2599     int left, right, back;
2600   } turn[] =
2601   {
2602     { 0,        0,              0 },
2603     { MV_DOWN,  MV_UP,          MV_RIGHT },
2604     { MV_UP,    MV_DOWN,        MV_LEFT },
2605     { 0,        0,              0 },
2606     { MV_LEFT,  MV_RIGHT,       MV_DOWN },
2607     { 0,0,0 },  { 0,0,0 },      { 0,0,0 },
2608     { MV_RIGHT, MV_LEFT,        MV_UP }
2609   };
2610
2611   int element = Feld[x][y];
2612   int old_move_dir = MovDir[x][y];
2613   int right_dir = turn[old_move_dir].right;
2614   int back_dir = turn[old_move_dir].back;
2615   int right_dx = move_xy[right_dir].x, right_dy = move_xy[right_dir].y;
2616   int right_x = x + right_dx, right_y = y + right_dy;
2617
2618   if (element == EL_PACMAN)
2619   {
2620     boolean can_turn_right = FALSE;
2621
2622     if (IN_LEV_FIELD(right_x, right_y) &&
2623         IS_EATABLE4PACMAN(Feld[right_x][right_y]))
2624       can_turn_right = TRUE;
2625
2626     if (can_turn_right)
2627       MovDir[x][y] = right_dir;
2628     else
2629       MovDir[x][y] = back_dir;
2630
2631     MovDelay[x][y] = 0;
2632   }
2633 }
2634
2635 static void StartMoving_MM(int x, int y)
2636 {
2637   int element = Feld[x][y];
2638
2639   if (Stop[x][y])
2640     return;
2641
2642   if (CAN_MOVE(element))
2643   {
2644     int newx, newy;
2645
2646     if (MovDelay[x][y])         /* wait some time before next movement */
2647     {
2648       MovDelay[x][y]--;
2649
2650       if (MovDelay[x][y])
2651         return;
2652     }
2653
2654     /* now make next step */
2655
2656     Moving2Blocked_MM(x, y, &newx, &newy);      /* get next screen position */
2657
2658     if (element == EL_PACMAN &&
2659         IN_LEV_FIELD(newx, newy) && IS_EATABLE4PACMAN(Feld[newx][newy]) &&
2660         !ObjHit(newx, newy, HIT_POS_CENTER))
2661     {
2662       Store[newx][newy] = Feld[newx][newy];
2663       Feld[newx][newy] = EL_EMPTY;
2664
2665       DrawField_MM(newx, newy);
2666     }
2667     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy) ||
2668              ObjHit(newx, newy, HIT_POS_CENTER))
2669     {
2670       /* object was running against a wall */
2671
2672       TurnRound(x, y);
2673
2674       return;
2675     }
2676
2677     InitMovingField_MM(x, y, MovDir[x][y]);
2678   }
2679
2680   if (MovDir[x][y])
2681     ContinueMoving_MM(x, y);
2682 }
2683
2684 static void ContinueMoving_MM(int x, int y)
2685 {
2686   int element = Feld[x][y];
2687   int direction = MovDir[x][y];
2688   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2689   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2690   int horiz_move = (dx!=0);
2691   int newx = x + dx, newy = y + dy;
2692   int step = (horiz_move ? dx : dy) * TILEX / 8;
2693
2694   MovPos[x][y] += step;
2695
2696   if (ABS(MovPos[x][y]) >= TILEX)       /* object reached its destination */
2697   {
2698     Feld[x][y] = EL_EMPTY;
2699     Feld[newx][newy] = element;
2700
2701     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
2702     MovDelay[newx][newy] = 0;
2703
2704     if (!CAN_MOVE(element))
2705       MovDir[newx][newy] = 0;
2706
2707     DrawField_MM(x, y);
2708     DrawField_MM(newx, newy);
2709
2710     Stop[newx][newy] = TRUE;
2711
2712     if (element == EL_PACMAN)
2713     {
2714       if (Store[newx][newy] == EL_BOMB)
2715         Bang_MM(newx, newy);
2716
2717       if (IS_WALL_AMOEBA(Store[newx][newy]) &&
2718           (LX + 2 * XS) / TILEX == newx &&
2719           (LY + 2 * YS) / TILEY == newy)
2720       {
2721         laser.num_edges--;
2722         ScanLaser();
2723       }
2724     }
2725   }
2726   else                          /* still moving on */
2727   {
2728     DrawField_MM(x, y);
2729   }
2730
2731   laser.redraw = TRUE;
2732 }
2733
2734 void ClickElement(int x, int y, int button)
2735 {
2736   static unsigned int click_delay = 0;
2737   static int click_delay_value = CLICK_DELAY;
2738   static boolean new_button = TRUE;
2739   int element;
2740
2741   if (button == -1)
2742   {
2743     /* initialize static variables */
2744     click_delay = 0;
2745     click_delay_value = CLICK_DELAY;
2746     new_button = TRUE;
2747
2748     return;
2749   }
2750
2751   /* do not rotate objects hit by the laser after the game was solved */
2752   if (game_mm.level_solved && Hit[x][y])
2753     return;
2754
2755   if (button == MB_RELEASED)
2756   {
2757     new_button = TRUE;
2758     click_delay_value = CLICK_DELAY;
2759
2760     /* release eventually hold auto-rotating mirror */
2761     RotateMirror(x, y, MB_RELEASED);
2762
2763     return;
2764   }
2765
2766   if (!FrameReached(&click_delay, click_delay_value) && !new_button)
2767     return;
2768
2769   if (button == MB_MIDDLEBUTTON)        /* middle button has no function */
2770     return;
2771
2772   if (!IN_LEV_FIELD(x, y))
2773     return;
2774
2775   if (Feld[x][y] == EL_EMPTY)
2776     return;
2777
2778   element = Feld[x][y];
2779
2780   if (IS_MIRROR(element) ||
2781       IS_BEAMER(element) ||
2782       IS_POLAR(element) ||
2783       IS_POLAR_CROSS(element) ||
2784       IS_DF_MIRROR(element) ||
2785       IS_DF_MIRROR_AUTO(element))
2786   {
2787     RotateMirror(x, y, button);
2788   }
2789   else if (IS_MCDUFFIN(element))
2790   {
2791     if (!laser.fuse_off)
2792     {
2793       DrawLaser(0, DL_LASER_DISABLED);
2794
2795       /*
2796       BackToFront();
2797       */
2798     }
2799
2800     element = get_rotated_element(element, BUTTON_ROTATION(button));
2801     laser.start_angle = get_element_angle(element);
2802
2803     InitLaser();
2804
2805     Feld[x][y] = element;
2806     DrawField_MM(x, y);
2807
2808     /*
2809     BackToFront();
2810     */
2811
2812     if (!laser.fuse_off)
2813       ScanLaser();
2814   }
2815   else if (element == EL_FUSE_ON && laser.fuse_off)
2816   {
2817     if (x != laser.fuse_x || y != laser.fuse_y)
2818       return;
2819
2820     laser.fuse_off = FALSE;
2821     laser.fuse_x = laser.fuse_y = -1;
2822
2823     DrawGraphic_MM(x, y, IMG_MM_FUSE_ACTIVE);
2824     ScanLaser();
2825   }
2826   else if (element == EL_FUSE_ON && !laser.fuse_off && new_button)
2827   {
2828     laser.fuse_off = TRUE;
2829     laser.fuse_x = x;
2830     laser.fuse_y = y;
2831     laser.overloaded = FALSE;
2832
2833     DrawLaser(0, DL_LASER_DISABLED);
2834     DrawGraphic_MM(x, y, IMG_MM_FUSE);
2835   }
2836   else if (element == EL_LIGHTBALL)
2837   {
2838     Bang_MM(x, y);
2839     RaiseScoreElement_MM(element);
2840     DrawLaser(0, DL_LASER_ENABLED);
2841   }
2842
2843   click_delay_value = (new_button ? CLICK_DELAY_FIRST : CLICK_DELAY);
2844   new_button = FALSE;
2845 }
2846
2847 void RotateMirror(int x, int y, int button)
2848 {
2849   if (button == MB_RELEASED)
2850   {
2851     /* release eventually hold auto-rotating mirror */
2852     hold_x = -1;
2853     hold_y = -1;
2854
2855     return;
2856   }
2857
2858   if (IS_MIRROR(Feld[x][y]) ||
2859       IS_POLAR_CROSS(Feld[x][y]) ||
2860       IS_POLAR(Feld[x][y]) ||
2861       IS_BEAMER(Feld[x][y]) ||
2862       IS_DF_MIRROR(Feld[x][y]) ||
2863       IS_GRID_STEEL_AUTO(Feld[x][y]) ||
2864       IS_GRID_WOOD_AUTO(Feld[x][y]))
2865   {
2866     Feld[x][y] = get_rotated_element(Feld[x][y], BUTTON_ROTATION(button));
2867   }
2868   else if (IS_DF_MIRROR_AUTO(Feld[x][y]))
2869   {
2870     if (button == MB_LEFTBUTTON)
2871     {
2872       /* left mouse button only for manual adjustment, no auto-rotating;
2873          freeze mirror for until mouse button released */
2874       hold_x = x;
2875       hold_y = y;
2876     }
2877     else if (button == MB_RIGHTBUTTON && (hold_x != x || hold_y != y))
2878     {
2879       Feld[x][y] = get_rotated_element(Feld[x][y], ROTATE_RIGHT);
2880     }
2881   }
2882
2883   if (IS_GRID_STEEL_AUTO(Feld[x][y]) || IS_GRID_WOOD_AUTO(Feld[x][y]))
2884   {
2885     int edge = Hit[x][y];
2886
2887     DrawField_MM(x, y);
2888
2889     if (edge > 0)
2890     {
2891       DrawLaser(edge - 1, DL_LASER_DISABLED);
2892       ScanLaser();
2893     }
2894   }
2895   else if (ObjHit(x, y, HIT_POS_CENTER))
2896   {
2897     int edge = Hit[x][y];
2898
2899     if (edge == 0)
2900     {
2901       Error(ERR_WARN, "RotateMirror: inconsistent field Hit[][]!\n");
2902       edge = 1;
2903     }
2904
2905     DrawLaser(edge - 1, DL_LASER_DISABLED);
2906     ScanLaser();
2907   }
2908   else
2909   {
2910     int check = 1;
2911
2912     if (ObjHit(x, y, HIT_POS_EDGE | HIT_POS_BETWEEN))
2913       check = 2;
2914
2915     DrawField_MM(x, y);
2916
2917     if ((IS_BEAMER(Feld[x][y]) ||
2918          IS_POLAR(Feld[x][y]) ||
2919          IS_POLAR_CROSS(Feld[x][y])) && x == ELX && y == ELY)
2920     {
2921       check = 0;
2922
2923       if (IS_BEAMER(Feld[x][y]))
2924       {
2925 #if 0
2926         printf("TEST (%d, %d) [%d] [%d]\n",
2927                LX, LY,
2928                laser.beamer_edge, laser.beamer[1].num);
2929 #endif
2930
2931         laser.num_edges--;
2932       }
2933
2934       ScanLaser();
2935     }
2936
2937     if (check == 2)
2938       DrawLaser(0, DL_LASER_ENABLED);
2939   }
2940 }
2941
2942 void AutoRotateMirrors()
2943 {
2944   int x, y;
2945
2946   if (!FrameReached(&rotate_delay, AUTO_ROTATE_DELAY))
2947     return;
2948
2949   for (x = 0; x < lev_fieldx; x++)
2950   {
2951     for (y = 0; y < lev_fieldy; y++)
2952     {
2953       int element = Feld[x][y];
2954
2955       /* do not rotate objects hit by the laser after the game was solved */
2956       if (game_mm.level_solved && Hit[x][y])
2957         continue;
2958
2959       if (IS_DF_MIRROR_AUTO(element) ||
2960           IS_GRID_WOOD_AUTO(element) ||
2961           IS_GRID_STEEL_AUTO(element) ||
2962           element == EL_REFRACTOR)
2963         RotateMirror(x, y, MB_RIGHTBUTTON);
2964     }
2965   }
2966 }
2967
2968 boolean ObjHit(int obx, int oby, int bits)
2969 {
2970   int i;
2971
2972   obx *= TILEX;
2973   oby *= TILEY;
2974
2975   if (bits & HIT_POS_CENTER)
2976   {
2977     if (CheckLaserPixel(SX + obx + 15,
2978                         SY + oby + 15))
2979       return TRUE;
2980   }
2981
2982   if (bits & HIT_POS_EDGE)
2983   {
2984     for (i = 0; i < 4; i++)
2985       if (CheckLaserPixel(SX + obx + 31 * (i % 2),
2986                           SY + oby + 31 * (i / 2)))
2987         return TRUE;
2988   }
2989
2990   if (bits & HIT_POS_BETWEEN)
2991   {
2992     for (i = 0; i < 4; i++)
2993       if (CheckLaserPixel(SX + 4 + obx + 22 * (i % 2),
2994                           SY + 4 + oby + 22 * (i / 2)))
2995         return TRUE;
2996   }
2997
2998   return FALSE;
2999 }
3000
3001 void DeletePacMan(int px, int py)
3002 {
3003   int i, j;
3004
3005   Bang_MM(px, py);
3006
3007   if (game_mm.num_pacman <= 1)
3008   {
3009     game_mm.num_pacman = 0;
3010     return;
3011   }
3012
3013   for (i = 0; i < game_mm.num_pacman; i++)
3014     if (game_mm.pacman[i].x == px && game_mm.pacman[i].y == py)
3015       break;
3016
3017   game_mm.num_pacman--;
3018
3019   for (j = i; j < game_mm.num_pacman; j++)
3020   {
3021     game_mm.pacman[j].x   = game_mm.pacman[j + 1].x;
3022     game_mm.pacman[j].y   = game_mm.pacman[j + 1].y;
3023     game_mm.pacman[j].dir = game_mm.pacman[j + 1].dir;
3024   }
3025 }
3026
3027 void ColorCycling(void)
3028 {
3029   static int CC, Cc = 0;
3030
3031   static int color, old = 0xF00, new = 0x010, mult = 1;
3032   static unsigned short red, green, blue;
3033
3034   if (color_status == STATIC_COLORS)
3035     return;
3036
3037   CC = FrameCounter;
3038
3039   if (CC < Cc || CC > Cc + 2)
3040   {
3041     Cc = CC;
3042
3043     color = old + new * mult;
3044     if (mult > 0)
3045       mult++;
3046     else
3047       mult--;
3048
3049     if (ABS(mult) == 16)
3050     {
3051       mult =- mult / 16;
3052       old = color;
3053       new = new << 4;
3054
3055       if (new > 0x100)
3056         new = 0x001;
3057     }
3058
3059     red   = 0x0e00 * ((color & 0xF00) >> 8);
3060     green = 0x0e00 * ((color & 0x0F0) >> 4);
3061     blue  = 0x0e00 * ((color & 0x00F));
3062     SetRGB(pen_magicolor[0], red, green, blue);
3063
3064     red   = 0x1111 * ((color & 0xF00) >> 8);
3065     green = 0x1111 * ((color & 0x0F0) >> 4);
3066     blue  = 0x1111 * ((color & 0x00F));
3067     SetRGB(pen_magicolor[1], red, green, blue);
3068   }
3069 }
3070
3071 static void GameActions_MM_Ext(struct MouseActionInfo action, boolean warp_mode)
3072 {
3073   int element;
3074   int x, y, i;
3075
3076   int r, d;
3077
3078   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
3079     Stop[x][y] = FALSE;
3080
3081   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
3082   {
3083     element = Feld[x][y];
3084
3085     if (!IS_MOVING(x, y) && CAN_MOVE(element))
3086       StartMoving_MM(x, y);
3087     else if (IS_MOVING(x, y))
3088       ContinueMoving_MM(x, y);
3089     else if (IS_EXPLODING(element))
3090       Explode_MM(x, y, Frame[x][y], EX_NORMAL);
3091     else if (element == EL_EXIT_OPENING)
3092       OpenExit(x, y);
3093     else if (element == EL_GRAY_BALL_OPENING)
3094       OpenSurpriseBall(x, y);
3095     else if (IS_WALL_CHANGING(element) && Store[x][y] == EL_WALL_ICE)
3096       MeltIce(x, y);
3097     else if (IS_WALL_CHANGING(element) && Store[x][y] == EL_WALL_AMOEBA)
3098       GrowAmoeba(x, y);
3099   }
3100
3101   AutoRotateMirrors();
3102
3103 #if 1
3104   /* !!! CHANGE THIS: REDRAW ONLY WHEN NEEDED !!! */
3105
3106   /* redraw after Explode_MM() ... */
3107   if (laser.redraw)
3108     DrawLaser(0, DL_LASER_ENABLED);
3109   laser.redraw = FALSE;
3110 #endif
3111
3112   CT = FrameCounter;
3113
3114   if (game_mm.num_pacman && FrameReached(&pacman_delay, PACMAN_MOVE_DELAY))
3115   {
3116     MovePacMen();
3117
3118     if (laser.num_damages > MAX_LASER_LEN && !laser.fuse_off)
3119     {
3120       DrawLaser(0, DL_LASER_DISABLED);
3121       ScanLaser();
3122     }
3123   }
3124
3125   if (FrameReached(&energy_delay, ENERGY_DELAY))
3126   {
3127     if (game_mm.energy_left > 0)
3128     {
3129       game_mm.energy_left--;
3130
3131 #if 0
3132       BlitBitmap(pix[PIX_DOOR], drawto,
3133                  DOOR_GFX_PAGEX5 + XX_ENERGY, DOOR_GFX_PAGEY1 + YY_ENERGY,
3134                  ENERGY_XSIZE, ENERGY_YSIZE - game_mm.energy_left,
3135                  DX_ENERGY, DY_ENERGY);
3136 #endif
3137       redraw_mask |= REDRAW_DOOR_1;
3138     }
3139     else if (setup.time_limit && !game_mm.game_over)
3140     {
3141       int i;
3142
3143       for (i = 15; i >= 0; i--)
3144       {
3145 #if 0
3146         SetRGB(pen_ray, 0x0000, 0x0000, i * color_scale);
3147 #endif
3148         pen_ray = GetPixelFromRGB(window,
3149                                   native_mm_level.laser_red   * 0x11 * i,
3150                                   native_mm_level.laser_green * 0x11 * i,
3151                                   native_mm_level.laser_blue  * 0x11 * i);
3152
3153         DrawLaser(0, DL_LASER_ENABLED);
3154         BackToFront();
3155         Delay(50);
3156       }
3157
3158       StopSound_MM(SND_MM_GAME_HEALTH_CHARGING);
3159 #if 0
3160       FadeMusic();
3161 #endif
3162
3163       DrawLaser(0, DL_LASER_DISABLED);
3164       game_mm.game_over = TRUE;
3165       game_mm.game_over_cause = GAME_OVER_NO_ENERGY;
3166
3167       SetTileCursorActive(FALSE);
3168
3169 #if 0
3170       if (Request("Out of magic energy ! Play it again ?",
3171                   REQ_ASK | REQ_STAY_CLOSED))
3172       {
3173         InitGame();
3174       }
3175       else
3176       {
3177         game_status = MAINMENU;
3178         DrawMainMenu();
3179       }
3180 #endif
3181
3182       return;
3183     }
3184   }
3185
3186   element = laser.dest_element;
3187
3188 #if 0
3189   if (element != Feld[ELX][ELY])
3190   {
3191     printf("element == %d, Feld[ELX][ELY] == %d\n",
3192            element, Feld[ELX][ELY]);
3193   }
3194 #endif
3195
3196   if (!laser.overloaded && laser.overload_value == 0 &&
3197       element != EL_BOMB &&
3198       element != EL_MINE &&
3199       element != EL_BALL_GRAY &&
3200       element != EL_BLOCK_STONE &&
3201       element != EL_BLOCK_WOOD &&
3202       element != EL_FUSE_ON &&
3203       element != EL_FUEL_FULL &&
3204       !IS_WALL_ICE(element) &&
3205       !IS_WALL_AMOEBA(element))
3206     return;
3207
3208   if (((laser.overloaded && laser.overload_value < MAX_LASER_OVERLOAD) ||
3209        (!laser.overloaded && laser.overload_value > 0)) &&
3210       FrameReached(&overload_delay, HEALTH_DELAY(laser.overloaded)))
3211   {
3212     if (laser.overloaded)
3213       laser.overload_value++;
3214     else
3215       laser.overload_value--;
3216
3217     if (game_mm.cheat_no_overload)
3218     {
3219       laser.overloaded = FALSE;
3220       laser.overload_value = 0;
3221     }
3222
3223     game_mm.laser_overload_value = laser.overload_value;
3224
3225     if (laser.overload_value < MAX_LASER_OVERLOAD - 8)
3226     {
3227       int color_up = 0xFF * laser.overload_value / MAX_LASER_OVERLOAD;
3228       int color_down = 0xFF - color_up;
3229
3230 #if 0
3231       SetRGB(pen_ray, (laser.overload_value / 6) * color_scale, 0x0000,
3232              (15 - (laser.overload_value / 6)) * color_scale);
3233 #endif
3234       pen_ray =
3235         GetPixelFromRGB(window,
3236                         (native_mm_level.laser_red  ? 0xFF : color_up),
3237                         (native_mm_level.laser_green ? color_down : 0x00),
3238                         (native_mm_level.laser_blue  ? color_down : 0x00));
3239
3240       DrawLaser(0, DL_LASER_ENABLED);
3241 #if 0
3242       BackToFront();
3243 #endif
3244     }
3245
3246     if (!laser.overloaded)
3247       StopSound_MM(SND_MM_GAME_HEALTH_CHARGING);
3248     else if (setup.sound_loops)
3249       PlaySoundLoop_MM(SND_MM_GAME_HEALTH_CHARGING);
3250     else
3251       PlaySound_MM(SND_MM_GAME_HEALTH_CHARGING);
3252
3253     if (laser.overloaded)
3254     {
3255 #if 0
3256       BlitBitmap(pix[PIX_DOOR], drawto,
3257                  DOOR_GFX_PAGEX4 + XX_OVERLOAD,
3258                  DOOR_GFX_PAGEY1 + YY_OVERLOAD + OVERLOAD_YSIZE
3259                  - laser.overload_value,
3260                  OVERLOAD_XSIZE, laser.overload_value,
3261                  DX_OVERLOAD, DY_OVERLOAD + OVERLOAD_YSIZE
3262                  - laser.overload_value);
3263 #endif
3264       redraw_mask |= REDRAW_DOOR_1;
3265     }
3266     else
3267     {
3268 #if 0
3269       BlitBitmap(pix[PIX_DOOR], drawto,
3270                  DOOR_GFX_PAGEX5 + XX_OVERLOAD, DOOR_GFX_PAGEY1 + YY_OVERLOAD,
3271                  OVERLOAD_XSIZE, OVERLOAD_YSIZE - laser.overload_value,
3272                  DX_OVERLOAD, DY_OVERLOAD);
3273 #endif
3274       redraw_mask |= REDRAW_DOOR_1;
3275     }
3276
3277     if (laser.overload_value == MAX_LASER_OVERLOAD)
3278     {
3279       int i;
3280
3281       for (i = 15; i >= 0; i--)
3282       {
3283 #if 0
3284         SetRGB(pen_ray, i * color_scale, 0x0000, 0x0000);
3285 #endif
3286
3287         pen_ray = GetPixelFromRGB(window, 0x11 * i, 0x00, 0x00);
3288
3289         DrawLaser(0, DL_LASER_ENABLED);
3290         BackToFront();
3291         Delay(50);
3292       }
3293
3294       DrawLaser(0, DL_LASER_DISABLED);
3295
3296       game_mm.game_over = TRUE;
3297       game_mm.game_over_cause = GAME_OVER_OVERLOADED;
3298
3299       SetTileCursorActive(FALSE);
3300
3301 #if 0
3302       if (Request("Magic spell hit Mc Duffin ! Play it again ?",
3303                   REQ_ASK | REQ_STAY_CLOSED))
3304       {
3305         InitGame();
3306       }
3307       else
3308       {
3309         game_status = MAINMENU;
3310         DrawMainMenu();
3311       }
3312 #endif
3313
3314       return;
3315     }
3316   }
3317
3318   if (laser.fuse_off)
3319     return;
3320
3321   CT -= Ct;
3322
3323   if (element == EL_BOMB && CT > native_mm_level.time_bomb)
3324   {
3325     if (game_mm.cheat_no_explosion)
3326       return;
3327
3328 #if 0
3329     laser.num_damages--;
3330     DrawLaser(0, DL_LASER_DISABLED);
3331     laser.num_edges = 0;
3332 #endif
3333
3334     Bang_MM(ELX, ELY);
3335
3336     laser.dest_element = EL_EXPLODING_OPAQUE;
3337
3338 #if 0
3339     Bang_MM(ELX, ELY);
3340     laser.num_damages--;
3341     DrawLaser(0, DL_LASER_DISABLED);
3342
3343     laser.num_edges = 0;
3344     Bang_MM(laser.start_edge.x, laser.start_edge.y);
3345
3346     if (Request("Bomb killed Mc Duffin ! Play it again ?",
3347                 REQ_ASK | REQ_STAY_CLOSED))
3348     {
3349       InitGame();
3350     }
3351     else
3352     {
3353       game_status = MAINMENU;
3354       DrawMainMenu();
3355     }
3356 #endif
3357
3358     return;
3359   }
3360
3361   if (element == EL_FUSE_ON && CT > native_mm_level.time_fuse)
3362   {
3363     laser.fuse_off = TRUE;
3364     laser.fuse_x = ELX;
3365     laser.fuse_y = ELY;
3366
3367     DrawLaser(0, DL_LASER_DISABLED);
3368     DrawGraphic_MM(ELX, ELY, IMG_MM_FUSE);
3369   }
3370
3371   if (element == EL_BALL_GRAY && CT > native_mm_level.time_ball)
3372   {
3373     static int new_elements[] =
3374     {
3375       EL_MIRROR_START,
3376       EL_MIRROR_FIXED_START,
3377       EL_POLAR_START,
3378       EL_POLAR_CROSS_START,
3379       EL_PACMAN_START,
3380       EL_KETTLE,
3381       EL_BOMB,
3382       EL_PRISM
3383     };
3384     int num_new_elements = sizeof(new_elements) / sizeof(int);
3385     int new_element = new_elements[RND(num_new_elements)];
3386
3387     Store[ELX][ELY] = new_element + RND(get_num_elements(new_element));
3388     Feld[ELX][ELY] = EL_GRAY_BALL_OPENING;
3389
3390     /* !!! CHECK AGAIN: Laser on Polarizer !!! */
3391     ScanLaser();
3392
3393     return;
3394
3395 #if 0
3396     int graphic;
3397
3398     switch (RND(5))
3399     {
3400       case 0:
3401         element = EL_MIRROR_START + RND(16);
3402         break;
3403       case 1:
3404         {
3405           int rnd = RND(3);
3406
3407           element = (rnd == 0 ? EL_KETTLE : rnd == 1 ? EL_BOMB : EL_PRISM);
3408         }
3409         break;
3410       default:
3411         {
3412           int rnd = RND(3);
3413
3414           element = (rnd == 0 ? EL_FUSE_ON :
3415                      rnd >= 1 && rnd <= 4 ? EL_PACMAN_RIGHT + rnd - 1 :
3416                      rnd >= 5 && rnd <= 20 ? EL_POLAR_START + rnd - 5 :
3417                      rnd >= 21 && rnd <= 24 ? EL_POLAR_CROSS_START + rnd - 21 :
3418                      EL_MIRROR_FIXED_START + rnd - 25);
3419         }
3420         break;
3421     }
3422
3423     graphic = el2gfx(element);
3424
3425     for (i = 0; i < 50; i++)
3426     {
3427       int x = RND(26);
3428       int y = RND(26);
3429
3430 #if 0
3431       BlitBitmap(pix[PIX_BACK], drawto,
3432                  SX + (graphic % GFX_PER_LINE) * TILEX + x,
3433                  SY + (graphic / GFX_PER_LINE) * TILEY + y, 6, 6,
3434                  SX + ELX * TILEX + x,
3435                  SY + ELY * TILEY + y);
3436 #endif
3437       MarkTileDirty(ELX, ELY);
3438       BackToFront();
3439
3440       DrawLaser(0, DL_LASER_ENABLED);
3441
3442       Delay(50);
3443     }
3444
3445     Feld[ELX][ELY] = element;
3446     DrawField_MM(ELX, ELY);
3447
3448 #if 0
3449     printf("NEW ELEMENT: (%d, %d)\n", ELX, ELY);
3450 #endif
3451
3452     /* above stuff: GRAY BALL -> PRISM !!! */
3453 /*
3454     LX = ELX * TILEX + 14;
3455     LY = ELY * TILEY + 14;
3456     if (laser.current_angle == (laser.current_angle >> 1) << 1)
3457       OK = 8;
3458     else
3459       OK = 4;
3460     LX -= OK * XS;
3461     LY -= OK * YS;
3462
3463     laser.num_edges -= 2;
3464     laser.num_damages--;
3465 */
3466
3467 #if 0
3468     for (i = (laser.num_damages > 0 ? laser.num_damages - 1 : 0); i>=0; i--)
3469       if (laser.damage[i].is_mirror)
3470         break;
3471
3472     if (i > 0)
3473       DrawLaser(laser.damage[i].edge - 1, DL_LASER_DISABLED);
3474     else
3475       DrawLaser(0, DL_LASER_DISABLED);
3476 #else
3477     DrawLaser(0, DL_LASER_DISABLED);
3478 #endif
3479
3480     ScanLaser();
3481
3482     /*
3483     printf("TEST ELEMENT: %d\n", Feld[0][0]);
3484     */
3485 #endif
3486
3487     return;
3488   }
3489
3490   if (IS_WALL_ICE(element) && CT > 50)
3491   {
3492     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_SHRINKING);
3493
3494     {
3495       Feld[ELX][ELY] = Feld[ELX][ELY] - EL_WALL_ICE + EL_WALL_CHANGING;
3496       Store[ELX][ELY] = EL_WALL_ICE;
3497       Store2[ELX][ELY] = laser.wall_mask;
3498
3499       laser.dest_element = Feld[ELX][ELY];
3500
3501       return;
3502     }
3503
3504     for (i = 0; i < 5; i++)
3505     {
3506       int phase = i + 1;
3507
3508       if (i == 4)
3509       {
3510         Feld[ELX][ELY] &= (laser.wall_mask ^ 0xFF);
3511         phase = 0;
3512       }
3513
3514       DrawWallsAnimation_MM(ELX, ELY, Feld[ELX][ELY], phase, laser.wall_mask);
3515       BackToFront();
3516       Delay(100);
3517     }
3518
3519     if (Feld[ELX][ELY] == EL_WALL_ICE)
3520       Feld[ELX][ELY] = EL_EMPTY;
3521
3522 /*
3523     laser.num_edges--;
3524     LX = laser.edge[laser.num_edges].x - (SX + 2);
3525     LY = laser.edge[laser.num_edges].y - (SY + 2);
3526 */
3527
3528     for (i = (laser.num_damages > 0 ? laser.num_damages - 1 : 0); i >= 0; i--)
3529       if (laser.damage[i].is_mirror)
3530         break;
3531
3532     if (i > 0)
3533       DrawLaser(laser.damage[i].edge - 1, DL_LASER_DISABLED);
3534     else
3535       DrawLaser(0, DL_LASER_DISABLED);
3536
3537     ScanLaser();
3538
3539     return;
3540   }
3541
3542   if (IS_WALL_AMOEBA(element) && CT > 60)
3543   {
3544     int k1, k2, k3, dx, dy, de, dm;
3545     int element2 = Feld[ELX][ELY];
3546
3547     if (element2 != EL_EMPTY && !IS_WALL_AMOEBA(element))
3548       return;
3549
3550     for (i = laser.num_damages - 1; i >= 0; i--)
3551       if (laser.damage[i].is_mirror)
3552         break;
3553
3554     r = laser.num_edges;
3555     d = laser.num_damages;
3556     k1 = i;
3557
3558     if (k1 > 0)
3559     {
3560       int x, y;
3561
3562       DrawLaser(laser.damage[k1].edge - 1, DL_LASER_DISABLED);
3563
3564       laser.num_edges++;
3565       DrawLaser(0, DL_LASER_ENABLED);
3566       laser.num_edges--;
3567
3568       x = laser.damage[k1].x;
3569       y = laser.damage[k1].y;
3570
3571       DrawField_MM(x, y);
3572     }
3573
3574     for (i = 0; i < 4; i++)
3575     {
3576       if (laser.wall_mask & (1 << i))
3577       {
3578         if (CheckLaserPixel(SX + ELX * TILEX + 14 + (i % 2) * 2,
3579                             SY + ELY * TILEY + 31 * (i / 2)))
3580           break;
3581
3582         if (CheckLaserPixel(SX + ELX * TILEX + 31 * (i % 2),
3583                             SY + ELY * TILEY + 14 + (i / 2) * 2))
3584           break;
3585       }
3586     }
3587
3588     k2 = i;
3589
3590     for (i = 0; i < 4; i++)
3591     {
3592       if (laser.wall_mask & (1 << i))
3593       {
3594         if (CheckLaserPixel(SX + ELX * TILEX + 31 * (i % 2),
3595                             SY + ELY * TILEY + 31 * (i / 2)))
3596           break;
3597       }
3598     }
3599
3600     k3 = i;
3601
3602     if (laser.num_beamers > 0 ||
3603         k1 < 1 || k2 < 4 || k3 < 4 ||
3604         CheckLaserPixel(SX + ELX * TILEX + 14,
3605                         SY + ELY * TILEY + 14))
3606     {
3607       laser.num_edges = r;
3608       laser.num_damages = d;
3609
3610       DrawLaser(0, DL_LASER_DISABLED);
3611     }
3612
3613     Feld[ELX][ELY] = element | laser.wall_mask;
3614
3615     dx = ELX;
3616     dy = ELY;
3617     de = Feld[ELX][ELY];
3618     dm = laser.wall_mask;
3619
3620 #if 1
3621     {
3622       int x = ELX, y = ELY;
3623       int wall_mask = laser.wall_mask;
3624
3625       ScanLaser();
3626       DrawLaser(0, DL_LASER_ENABLED);
3627
3628       PlayLevelSound_MM(dx, dy, element, MM_ACTION_GROWING);
3629
3630       Feld[x][y] = Feld[x][y] - EL_WALL_AMOEBA + EL_WALL_CHANGING;
3631       Store[x][y] = EL_WALL_AMOEBA;
3632       Store2[x][y] = wall_mask;
3633
3634       return;
3635     }
3636 #endif
3637
3638     DrawWallsAnimation_MM(dx, dy, de, 4, dm);
3639     ScanLaser();
3640     DrawLaser(0, DL_LASER_ENABLED);
3641
3642     PlayLevelSound_MM(dx, dy, element, MM_ACTION_GROWING);
3643
3644     for (i = 4; i >= 0; i--)
3645     {
3646       DrawWallsAnimation_MM(dx, dy, de, i, dm);
3647
3648       BackToFront();
3649       Delay(20);
3650     }
3651
3652     DrawLaser(0, DL_LASER_ENABLED);
3653
3654     return;
3655   }
3656
3657   if ((element == EL_BLOCK_WOOD || element == EL_BLOCK_STONE) &&
3658       laser.stops_inside_element && CT > native_mm_level.time_block)
3659   {
3660     int x, y;
3661     int k;
3662
3663     if (ABS(XS) > ABS(YS))
3664       k = 0;
3665     else
3666       k = 1;
3667     if (XS < YS)
3668       k += 2;
3669
3670     for (i = 0; i < 4; i++)
3671     {
3672       if (i)
3673         k++;
3674       if (k > 3)
3675         k = 0;
3676
3677       x = ELX + Step[k * 4].x;
3678       y = ELY + Step[k * 4].y;
3679
3680       if (!IN_LEV_FIELD(x, y) || Feld[x][y] != EL_EMPTY)
3681         continue;
3682
3683       if (ObjHit(x, y, HIT_POS_CENTER | HIT_POS_EDGE | HIT_POS_BETWEEN))
3684         continue;
3685
3686       break;
3687     }
3688
3689     if (i > 3)
3690     {
3691       laser.overloaded = (element == EL_BLOCK_STONE);
3692
3693       return;
3694     }
3695
3696     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_PUSHING);
3697
3698     Feld[ELX][ELY] = 0;
3699     Feld[x][y] = element;
3700
3701     DrawGraphic_MM(ELX, ELY, IMG_EMPTY);
3702     DrawField_MM(x, y);
3703
3704     if (element == EL_BLOCK_STONE && Box[ELX][ELY])
3705     {
3706       DrawLaser(Box[ELX][ELY] - 1, DL_LASER_DISABLED);
3707       DrawLaser(laser.num_edges - 1, DL_LASER_ENABLED);
3708     }
3709
3710     ScanLaser();
3711
3712     return;
3713   }
3714
3715   if (element == EL_FUEL_FULL && CT > 10)
3716   {
3717     for (i = game_mm.energy_left; i <= MAX_LASER_ENERGY; i+=2)
3718     {
3719 #if 0
3720       BlitBitmap(pix[PIX_DOOR], drawto,
3721                  DOOR_GFX_PAGEX4 + XX_ENERGY,
3722                  DOOR_GFX_PAGEY1 + YY_ENERGY + ENERGY_YSIZE - i,
3723                  ENERGY_XSIZE, i, DX_ENERGY,
3724                  DY_ENERGY + ENERGY_YSIZE - i);
3725 #endif
3726
3727       redraw_mask |= REDRAW_DOOR_1;
3728       BackToFront();
3729
3730       Delay(20);
3731     }
3732
3733     game_mm.energy_left = MAX_LASER_ENERGY;
3734     Feld[ELX][ELY] = EL_FUEL_EMPTY;
3735     DrawField_MM(ELX, ELY);
3736
3737     DrawLaser(0, DL_LASER_ENABLED);
3738
3739     return;
3740   }
3741
3742   return;
3743 }
3744
3745 void GameActions_MM(struct MouseActionInfo action, boolean warp_mode)
3746 {
3747   ClickElement(action.lx, action.ly, action.button);
3748
3749   GameActions_MM_Ext(action, warp_mode);
3750 }
3751
3752 void MovePacMen()
3753 {
3754   int mx, my, ox, oy, nx, ny;
3755   int element;
3756   int l;
3757
3758   if (++pacman_nr >= game_mm.num_pacman)
3759     pacman_nr = 0;
3760
3761   game_mm.pacman[pacman_nr].dir--;
3762
3763   for (l = 1; l < 5; l++)
3764   {
3765     game_mm.pacman[pacman_nr].dir++;
3766
3767     if (game_mm.pacman[pacman_nr].dir > 4)
3768       game_mm.pacman[pacman_nr].dir = 1;
3769
3770     if (game_mm.pacman[pacman_nr].dir % 2)
3771     {
3772       mx = 0;
3773       my = game_mm.pacman[pacman_nr].dir - 2;
3774     }
3775     else
3776     {
3777       my = 0;
3778       mx = 3 - game_mm.pacman[pacman_nr].dir;
3779     }
3780
3781     ox = game_mm.pacman[pacman_nr].x;
3782     oy = game_mm.pacman[pacman_nr].y;
3783     nx = ox + mx;
3784     ny = oy + my;
3785     element = Feld[nx][ny];
3786
3787     if (nx < 0 || nx > 15 || ny < 0 || ny > 11)
3788       continue;
3789
3790     if (!IS_EATABLE4PACMAN(element))
3791       continue;
3792
3793     if (ObjHit(nx, ny, HIT_POS_CENTER))
3794       continue;
3795
3796     Feld[ox][oy] = EL_EMPTY;
3797     Feld[nx][ny] =
3798       EL_PACMAN_RIGHT - 1 +
3799       (game_mm.pacman[pacman_nr].dir - 1 +
3800        (game_mm.pacman[pacman_nr].dir % 2) * 2);
3801
3802     game_mm.pacman[pacman_nr].x = nx;
3803     game_mm.pacman[pacman_nr].y = ny;
3804
3805     DrawGraphic_MM(ox, oy, IMG_EMPTY);
3806
3807     if (element != EL_EMPTY)
3808     {
3809       int graphic = el2gfx(Feld[nx][ny]);
3810       Bitmap *bitmap;
3811       int src_x, src_y;
3812       int i;
3813
3814       getGraphicSource(graphic, 0, &bitmap, &src_x, &src_y);
3815
3816       CT = FrameCounter;
3817       ox = SX + ox * TILEX;
3818       oy = SY + oy * TILEY;
3819
3820       for (i = 1; i < 33; i += 2)
3821         BlitBitmap(bitmap, window,
3822                    src_x, src_y, TILEX, TILEY,
3823                    ox + i * mx, oy + i * my);
3824       Ct = Ct + FrameCounter - CT;
3825     }
3826
3827     DrawField_MM(nx, ny);
3828     BackToFront();
3829
3830     if (!laser.fuse_off)
3831     {
3832       DrawLaser(0, DL_LASER_ENABLED);
3833
3834       if (ObjHit(nx, ny, HIT_POS_BETWEEN))
3835       {
3836         AddDamagedField(nx, ny);
3837
3838         laser.damage[laser.num_damages - 1].edge = 0;
3839       }
3840     }
3841
3842     if (element == EL_BOMB)
3843       DeletePacMan(nx, ny);
3844
3845     if (IS_WALL_AMOEBA(element) &&
3846         (LX + 2 * XS) / TILEX == nx &&
3847         (LY + 2 * YS) / TILEY == ny)
3848     {
3849       laser.num_edges--;
3850       ScanLaser();
3851     }
3852
3853     break;
3854   }
3855 }
3856
3857 void GameWon_MM()
3858 {
3859   int hi_pos;
3860   boolean raise_level = FALSE;
3861
3862 #if 0
3863   if (local_player->MovPos)
3864     return;
3865
3866   local_player->LevelSolved = FALSE;
3867 #endif
3868
3869   if (game_mm.energy_left)
3870   {
3871     if (setup.sound_loops)
3872       PlaySoundExt(SND_SIRR, SOUND_MAX_VOLUME, SOUND_MAX_RIGHT,
3873                    SND_CTRL_PLAY_LOOP);
3874
3875     while (game_mm.energy_left > 0)
3876     {
3877       if (!setup.sound_loops)
3878         PlaySoundStereo(SND_SIRR, SOUND_MAX_RIGHT);
3879
3880       /*
3881       if (game_mm.energy_left > 0 && !(game_mm.energy_left % 10))
3882         RaiseScore_MM(native_mm_level.score[SC_ZEITBONUS]);
3883       */
3884
3885       RaiseScore_MM(5);
3886
3887       game_mm.energy_left--;
3888       if (game_mm.energy_left >= 0)
3889       {
3890 #if 0
3891         BlitBitmap(pix[PIX_DOOR], drawto,
3892                    DOOR_GFX_PAGEX5 + XX_ENERGY, DOOR_GFX_PAGEY1 + YY_ENERGY,
3893                    ENERGY_XSIZE, ENERGY_YSIZE - game_mm.energy_left,
3894                    DX_ENERGY, DY_ENERGY);
3895 #endif
3896         redraw_mask |= REDRAW_DOOR_1;
3897       }
3898
3899       BackToFront();
3900       Delay(10);
3901     }
3902
3903     if (setup.sound_loops)
3904       StopSound(SND_SIRR);
3905   }
3906   else if (native_mm_level.time == 0)           /* level without time limit */
3907   {
3908     if (setup.sound_loops)
3909       PlaySoundExt(SND_SIRR, SOUND_MAX_VOLUME, SOUND_MAX_RIGHT,
3910                    SND_CTRL_PLAY_LOOP);
3911
3912     while (TimePlayed < 999)
3913     {
3914       if (!setup.sound_loops)
3915         PlaySoundStereo(SND_SIRR, SOUND_MAX_RIGHT);
3916       if (TimePlayed < 999 && !(TimePlayed % 10))
3917         RaiseScore_MM(native_mm_level.score[SC_TIME_BONUS]);
3918       if (TimePlayed < 900 && !(TimePlayed % 10))
3919         TimePlayed += 10;
3920       else
3921         TimePlayed++;
3922
3923       /*
3924       DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FONT_TEXT_2);
3925       */
3926
3927       BackToFront();
3928       Delay(10);
3929     }
3930
3931     if (setup.sound_loops)
3932       StopSound(SND_SIRR);
3933   }
3934
3935 #if 0
3936   FadeSounds();
3937 #endif
3938
3939   CloseDoor(DOOR_CLOSE_1);
3940
3941   Request("Level solved !", REQ_CONFIRM);
3942
3943   if (level_nr == leveldir_current->handicap_level)
3944   {
3945     leveldir_current->handicap_level++;
3946     SaveLevelSetup_SeriesInfo();
3947   }
3948
3949   if (level_editor_test_game)
3950     game_mm.score = -1;         /* no highscore when playing from editor */
3951   else if (level_nr < leveldir_current->last_level)
3952     raise_level = TRUE;         /* advance to next level */
3953
3954   if ((hi_pos = NewHiScore_MM()) >= 0)
3955   {
3956     game_status = HALLOFFAME;
3957
3958     // DrawHallOfFame(hi_pos);
3959
3960     if (raise_level)
3961       level_nr++;
3962   }
3963   else
3964   {
3965     game_status = MAINMENU;
3966
3967     if (raise_level)
3968       level_nr++;
3969
3970     // DrawMainMenu();
3971   }
3972
3973   BackToFront();
3974 }
3975
3976 int NewHiScore_MM()
3977 {
3978   int k, l;
3979   int position = -1;
3980
3981   // LoadScore(level_nr);
3982
3983   if (strcmp(setup.player_name, EMPTY_PLAYER_NAME) == 0 ||
3984       game_mm.score < highscore[MAX_SCORE_ENTRIES - 1].Score)
3985     return -1;
3986
3987   for (k = 0; k < MAX_SCORE_ENTRIES; k++)
3988   {
3989     if (game_mm.score > highscore[k].Score)
3990     {
3991       /* player has made it to the hall of fame */
3992
3993       if (k < MAX_SCORE_ENTRIES - 1)
3994       {
3995         int m = MAX_SCORE_ENTRIES - 1;
3996
3997 #ifdef ONE_PER_NAME
3998         for (l = k; l < MAX_SCORE_ENTRIES; l++)
3999           if (!strcmp(setup.player_name, highscore[l].Name))
4000             m = l;
4001         if (m == k)     /* player's new highscore overwrites his old one */
4002           goto put_into_list;
4003 #endif
4004
4005         for (l = m; l>k; l--)
4006         {
4007           strcpy(highscore[l].Name, highscore[l - 1].Name);
4008           highscore[l].Score = highscore[l - 1].Score;
4009         }
4010       }
4011
4012 #ifdef ONE_PER_NAME
4013       put_into_list:
4014 #endif
4015       strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
4016       highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
4017       highscore[k].Score = game_mm.score;
4018       position = k;
4019
4020       break;
4021     }
4022
4023 #ifdef ONE_PER_NAME
4024     else if (!strncmp(setup.player_name, highscore[k].Name,
4025                       MAX_PLAYER_NAME_LEN))
4026       break;    /* player already there with a higher score */
4027 #endif
4028
4029   }
4030
4031   // if (position >= 0)
4032   //   SaveScore(level_nr);
4033
4034   return position;
4035 }
4036
4037 static void InitMovingField_MM(int x, int y, int direction)
4038 {
4039   int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
4040   int newy = y + (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
4041
4042   MovDir[x][y] = direction;
4043   MovDir[newx][newy] = direction;
4044
4045   if (Feld[newx][newy] == EL_EMPTY)
4046     Feld[newx][newy] = EL_BLOCKED;
4047 }
4048
4049 static void Moving2Blocked_MM(int x, int y, int *goes_to_x, int *goes_to_y)
4050 {
4051   int direction = MovDir[x][y];
4052   int newx = x + (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
4053   int newy = y + (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
4054
4055   *goes_to_x = newx;
4056   *goes_to_y = newy;
4057 }
4058
4059 static void Blocked2Moving_MM(int x, int y,
4060                               int *comes_from_x, int *comes_from_y)
4061 {
4062   int oldx = x, oldy = y;
4063   int direction = MovDir[x][y];
4064
4065   if (direction == MV_LEFT)
4066     oldx++;
4067   else if (direction == MV_RIGHT)
4068     oldx--;
4069   else if (direction == MV_UP)
4070     oldy++;
4071   else if (direction == MV_DOWN)
4072     oldy--;
4073
4074   *comes_from_x = oldx;
4075   *comes_from_y = oldy;
4076 }
4077
4078 static int MovingOrBlocked2Element_MM(int x, int y)
4079 {
4080   int element = Feld[x][y];
4081
4082   if (element == EL_BLOCKED)
4083   {
4084     int oldx, oldy;
4085
4086     Blocked2Moving_MM(x, y, &oldx, &oldy);
4087
4088     return Feld[oldx][oldy];
4089   }
4090
4091   return element;
4092 }
4093
4094 #if 0
4095 static void RemoveField(int x, int y)
4096 {
4097   Feld[x][y] = EL_EMPTY;
4098   MovPos[x][y] = 0;
4099   MovDir[x][y] = 0;
4100   MovDelay[x][y] = 0;
4101 }
4102 #endif
4103
4104 static void RemoveMovingField_MM(int x, int y)
4105 {
4106   int oldx = x, oldy = y, newx = x, newy = y;
4107
4108   if (Feld[x][y] != EL_BLOCKED && !IS_MOVING(x, y))
4109     return;
4110
4111   if (IS_MOVING(x, y))
4112   {
4113     Moving2Blocked_MM(x, y, &newx, &newy);
4114     if (Feld[newx][newy] != EL_BLOCKED)
4115       return;
4116   }
4117   else if (Feld[x][y] == EL_BLOCKED)
4118   {
4119     Blocked2Moving_MM(x, y, &oldx, &oldy);
4120     if (!IS_MOVING(oldx, oldy))
4121       return;
4122   }
4123
4124   Feld[oldx][oldy] = EL_EMPTY;
4125   Feld[newx][newy] = EL_EMPTY;
4126   MovPos[oldx][oldy] = MovDir[oldx][oldy] = MovDelay[oldx][oldy] = 0;
4127   MovPos[newx][newy] = MovDir[newx][newy] = MovDelay[newx][newy] = 0;
4128
4129   DrawLevelField_MM(oldx, oldy);
4130   DrawLevelField_MM(newx, newy);
4131 }
4132
4133 void PlaySoundLevel(int x, int y, int sound_nr)
4134 {
4135   int sx = SCREENX(x), sy = SCREENY(y);
4136   int volume, stereo;
4137   int silence_distance = 8;
4138
4139   if ((!setup.sound_simple && !IS_LOOP_SOUND(sound_nr)) ||
4140       (!setup.sound_loops && IS_LOOP_SOUND(sound_nr)))
4141     return;
4142
4143   if (!IN_LEV_FIELD(x, y) ||
4144       sx < -silence_distance || sx >= SCR_FIELDX+silence_distance ||
4145       sy < -silence_distance || sy >= SCR_FIELDY+silence_distance)
4146     return;
4147
4148   volume = SOUND_MAX_VOLUME;
4149
4150 #ifndef MSDOS
4151   stereo = (sx - SCR_FIELDX/2) * 12;
4152 #else
4153   stereo = SOUND_MIDDLE + (2 * sx - (SCR_FIELDX - 1)) * 5;
4154   if (stereo > SOUND_MAX_RIGHT)
4155     stereo = SOUND_MAX_RIGHT;
4156   if (stereo < SOUND_MAX_LEFT)
4157     stereo = SOUND_MAX_LEFT;
4158 #endif
4159
4160   if (!IN_SCR_FIELD(sx, sy))
4161   {
4162     int dx = ABS(sx - SCR_FIELDX/2) - SCR_FIELDX/2;
4163     int dy = ABS(sy - SCR_FIELDY/2) - SCR_FIELDY/2;
4164
4165     volume -= volume * (dx > dy ? dx : dy) / silence_distance;
4166   }
4167
4168   PlaySoundExt(sound_nr, volume, stereo, SND_CTRL_PLAY_SOUND);
4169 }
4170
4171 static void RaiseScore_MM(int value)
4172 {
4173   game_mm.score += value;
4174
4175 #if 0
4176   DrawText(DX_SCORE, DY_SCORE, int2str(game_mm.score, 4),
4177            FONT_TEXT_2);
4178 #endif
4179 }
4180
4181 void RaiseScoreElement_MM(int element)
4182 {
4183   switch(element)
4184   {
4185     case EL_PACMAN:
4186     case EL_PACMAN_RIGHT:
4187     case EL_PACMAN_UP:
4188     case EL_PACMAN_LEFT:
4189     case EL_PACMAN_DOWN:
4190       RaiseScore_MM(native_mm_level.score[SC_PACMAN]);
4191       break;
4192
4193     case EL_KEY:
4194       RaiseScore_MM(native_mm_level.score[SC_KEY]);
4195       break;
4196
4197     case EL_KETTLE:
4198     case EL_CELL:
4199       RaiseScore_MM(native_mm_level.score[SC_COLLECTIBLE]);
4200       break;
4201
4202     case EL_LIGHTBALL:
4203       RaiseScore_MM(native_mm_level.score[SC_LIGHTBALL]);
4204       break;
4205
4206     default:
4207       break;
4208   }
4209 }
4210
4211
4212 /* ------------------------------------------------------------------------- */
4213 /* Mirror Magic game engine snapshot handling functions                      */
4214 /* ------------------------------------------------------------------------- */
4215
4216 void SaveEngineSnapshotValues_MM(ListNode **buffers)
4217 {
4218   int x, y;
4219
4220   engine_snapshot_mm.game_mm = game_mm;
4221   engine_snapshot_mm.laser = laser;
4222
4223   for (x = 0; x < MAX_PLAYFIELD_WIDTH; x++)
4224   {
4225     for (y = 0; y < MAX_PLAYFIELD_HEIGHT; y++)
4226     {
4227       engine_snapshot_mm.Ur[x][y]    = Ur[x][y];
4228       engine_snapshot_mm.Hit[x][y]   = Hit[x][y];
4229       engine_snapshot_mm.Box[x][y]   = Box[x][y];
4230       engine_snapshot_mm.Angle[x][y] = Angle[x][y];
4231       engine_snapshot_mm.Frame[x][y] = Frame[x][y];
4232     }
4233   }
4234
4235   engine_snapshot_mm.LX = LX;
4236   engine_snapshot_mm.LY = LY;
4237   engine_snapshot_mm.XS = XS;
4238   engine_snapshot_mm.YS = YS;
4239   engine_snapshot_mm.ELX = ELX;
4240   engine_snapshot_mm.ELY = ELY;
4241   engine_snapshot_mm.CT = CT;
4242   engine_snapshot_mm.Ct = Ct;
4243
4244   engine_snapshot_mm.last_LX = last_LX;
4245   engine_snapshot_mm.last_LY = last_LY;
4246   engine_snapshot_mm.last_hit_mask = last_hit_mask;
4247   engine_snapshot_mm.hold_x = hold_x;
4248   engine_snapshot_mm.hold_y = hold_y;
4249   engine_snapshot_mm.pacman_nr = pacman_nr;
4250
4251   engine_snapshot_mm.rotate_delay = rotate_delay;
4252   engine_snapshot_mm.pacman_delay = pacman_delay;
4253   engine_snapshot_mm.energy_delay = energy_delay;
4254   engine_snapshot_mm.overload_delay = overload_delay;
4255 }
4256
4257 void LoadEngineSnapshotValues_MM()
4258 {
4259   int x, y;
4260
4261   /* stored engine snapshot buffers already restored at this point */
4262
4263   game_mm = engine_snapshot_mm.game_mm;
4264   laser   = engine_snapshot_mm.laser;
4265
4266   for (x = 0; x < MAX_PLAYFIELD_WIDTH; x++)
4267   {
4268     for (y = 0; y < MAX_PLAYFIELD_HEIGHT; y++)
4269     {
4270       Ur[x][y]    = engine_snapshot_mm.Ur[x][y];
4271       Hit[x][y]   = engine_snapshot_mm.Hit[x][y];
4272       Box[x][y]   = engine_snapshot_mm.Box[x][y];
4273       Angle[x][y] = engine_snapshot_mm.Angle[x][y];
4274       Frame[x][y] = engine_snapshot_mm.Frame[x][y];
4275     }
4276   }
4277
4278   LX  = engine_snapshot_mm.LX;
4279   LY  = engine_snapshot_mm.LY;
4280   XS  = engine_snapshot_mm.XS;
4281   YS  = engine_snapshot_mm.YS;
4282   ELX = engine_snapshot_mm.ELX;
4283   ELY = engine_snapshot_mm.ELY;
4284   CT  = engine_snapshot_mm.CT;
4285   Ct  = engine_snapshot_mm.Ct;
4286
4287   last_LX       = engine_snapshot_mm.last_LX;
4288   last_LY       = engine_snapshot_mm.last_LY;
4289   last_hit_mask = engine_snapshot_mm.last_hit_mask;
4290   hold_x        = engine_snapshot_mm.hold_x;
4291   hold_y        = engine_snapshot_mm.hold_y;
4292   pacman_nr     = engine_snapshot_mm.pacman_nr;
4293
4294   rotate_delay   = engine_snapshot_mm.rotate_delay;
4295   pacman_delay   = engine_snapshot_mm.pacman_delay;
4296   energy_delay   = engine_snapshot_mm.energy_delay;
4297   overload_delay = engine_snapshot_mm.overload_delay;
4298
4299   RedrawPlayfield_MM(TRUE);
4300 }
4301
4302 static int getAngleFromTouchDelta(int dx, int dy,  int base)
4303 {
4304   double pi = 3.141592653;
4305   double rad = atan2((double)-dy, (double)dx);
4306   double rad2 = (rad < 0 ? rad + 2 * pi : rad);
4307   double deg = rad2 * 180.0 / pi;
4308
4309   return (int)(deg * base / 360.0 + 0.5) % base;
4310 }
4311
4312 int getButtonFromTouchPosition(int x, int y, int dst_mx, int dst_my)
4313 {
4314   // calculate start (source) position to be at the middle of the tile
4315   int src_mx = SX + x * TILESIZE_VAR + TILESIZE_VAR / 2;
4316   int src_my = SY + y * TILESIZE_VAR + TILESIZE_VAR / 2;
4317   int dx = dst_mx - src_mx;
4318   int dy = dst_my - src_my;
4319   int element;
4320   int base = 16;
4321   int phases = 16;
4322   int angle_old = -1;
4323   int angle_new = -1;
4324   int button = 0;
4325   int i;
4326
4327   if (!IN_LEV_FIELD(x, y))
4328     return 0;
4329
4330   element = Feld[x][y];
4331
4332   if (!IS_MCDUFFIN(element) &&
4333       !IS_MIRROR(element) &&
4334       !IS_BEAMER(element) &&
4335       !IS_POLAR(element) &&
4336       !IS_POLAR_CROSS(element) &&
4337       !IS_DF_MIRROR(element))
4338     return 0;
4339
4340   angle_old = get_element_angle(element);
4341
4342   if (IS_MCDUFFIN(element))
4343   {
4344     angle_new = (dx > 0 && ABS(dy) < ABS(dx) ? ANG_RAY_RIGHT :
4345                  dy < 0 && ABS(dx) < ABS(dy) ? ANG_RAY_UP :
4346                  dx < 0 && ABS(dy) < ABS(dx) ? ANG_RAY_LEFT :
4347                  dy > 0 && ABS(dx) < ABS(dy) ? ANG_RAY_DOWN :
4348                  -1);
4349   }
4350   else if (IS_MIRROR(element) ||
4351            IS_DF_MIRROR(element))
4352   {
4353     for (i = 0; i < laser.num_damages; i++)
4354     {
4355       if (laser.damage[i].x == x &&
4356           laser.damage[i].y == y &&
4357           ObjHit(x, y, HIT_POS_CENTER))
4358       {
4359         angle_old = get_mirrored_angle(laser.damage[i].angle, angle_old);
4360         angle_new = getAngleFromTouchDelta(dx, dy, base) % phases;
4361
4362         break;
4363       }
4364     }
4365   }
4366
4367   if (angle_new == -1)
4368   {
4369     if (IS_MIRROR(element) ||
4370         IS_DF_MIRROR(element) ||
4371         IS_POLAR(element))
4372       base = 32;
4373
4374     if (IS_POLAR_CROSS(element))
4375       phases = 4;
4376
4377     angle_new = getAngleFromTouchDelta(dx, dy, base) % phases;
4378   }
4379
4380   button = (angle_new == angle_old ? 0 :
4381             (angle_new - angle_old + phases) % phases < (phases / 2) ?
4382             MB_LEFTBUTTON : MB_RIGHTBUTTON);
4383
4384   return button;
4385 }