removed some unused stuff from MM engine code
[rocksndiamonds.git] / 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(void)
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(void)
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(void)
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(void)
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   DrawLevel_MM();
664 }
665
666 void InitGameActions_MM(void)
667 {
668   int num_init_game_frames = INIT_GAME_ACTIONS_DELAY;
669   int cycle_steps_done = 0;
670   int i;
671
672   InitLaser();
673
674   for (i = 0; i <= num_init_game_frames; i++)
675   {
676     if (i == num_init_game_frames)
677       StopSound_MM(SND_MM_GAME_LEVELTIME_CHARGING);
678     else if (setup.sound_loops)
679       PlaySoundLoop_MM(SND_MM_GAME_LEVELTIME_CHARGING);
680     else
681       PlaySound_MM(SND_MM_GAME_LEVELTIME_CHARGING);
682
683     game_mm.energy_left = native_mm_level.time * i / num_init_game_frames;
684
685     UpdateAndDisplayGameControlValues();
686
687     while (cycle_steps_done < NUM_INIT_CYCLE_STEPS * i / num_init_game_frames)
688     {
689       InitCycleElements_RotateSingleStep();
690
691       cycle_steps_done++;
692     }
693
694     BackToFront();
695
696     ColorCycling();
697
698 #ifdef DEBUG
699     if (setup.quick_doors)
700       continue;
701 #endif
702   }
703
704   ScanLaser();
705
706   if (game_mm.kettles_still_needed == 0)
707     CheckExitMM();
708
709   SetTileCursorXY(laser.start_edge.x, laser.start_edge.y);
710   SetTileCursorActive(TRUE);
711 }
712
713 void AddLaserEdge(int lx, int ly)
714 {
715   int clx = dSX + lx;
716   int cly = dSY + ly;
717
718   if (clx < -2 || cly < -2 || clx >= SXSIZE + 2 || cly >= SYSIZE + 2)
719   {
720     Error(ERR_WARN, "AddLaserEdge: out of bounds: %d, %d", lx, ly);
721
722     return;
723   }
724
725   laser.edge[laser.num_edges].x = cSX2 + lx;
726   laser.edge[laser.num_edges].y = cSY2 + ly;
727   laser.num_edges++;
728
729   laser.redraw = TRUE;
730 }
731
732 void AddDamagedField(int ex, int ey)
733 {
734   laser.damage[laser.num_damages].is_mirror = FALSE;
735   laser.damage[laser.num_damages].angle = laser.current_angle;
736   laser.damage[laser.num_damages].edge = laser.num_edges;
737   laser.damage[laser.num_damages].x = ex;
738   laser.damage[laser.num_damages].y = ey;
739   laser.num_damages++;
740 }
741
742 static boolean StepBehind(void)
743 {
744   if (laser.num_edges)
745   {
746     int x = LX - XS;
747     int y = LY - YS;
748     int last_x = laser.edge[laser.num_edges - 1].x - cSX2;
749     int last_y = laser.edge[laser.num_edges - 1].y - cSY2;
750
751     return ((x - last_x) * XS < 0 || (y - last_y) * YS < 0);
752   }
753
754   return FALSE;
755 }
756
757 static int getMaskFromElement(int element)
758 {
759   if (IS_GRID(element))
760     return IMG_MM_MASK_GRID_1 + get_element_phase(element);
761   else if (IS_MCDUFFIN(element))
762     return IMG_MM_MASK_MCDUFFIN_RIGHT + get_element_phase(element);
763   else if (IS_RECTANGLE(element) || IS_DF_GRID(element))
764     return IMG_MM_MASK_RECTANGLE;
765   else
766     return IMG_MM_MASK_CIRCLE;
767 }
768
769 static int ScanPixel(void)
770 {
771   int hit_mask = 0;
772
773 #if 0
774   printf("ScanPixel: start scanning at (%d, %d) [%d, %d] [%d, %d]\n",
775          LX, LY, LX / TILEX, LY / TILEY, LX % TILEX, LY % TILEY);
776 #endif
777
778   // follow laser beam until it hits something (at least the screen border)
779   while (hit_mask == HIT_MASK_NO_HIT)
780   {
781     int i;
782
783 #if 0
784     // for safety
785     if (SX + LX < REAL_SX || SX + LX >= REAL_SX + FULL_SXSIZE ||
786         SY + LY < REAL_SY || SY + LY >= REAL_SY + FULL_SYSIZE)
787     {
788       printf("ScanPixel: touched screen border!\n");
789
790       return HIT_MASK_ALL;
791     }
792 #endif
793
794     for (i = 0; i < 4; i++)
795     {
796       int px = LX + (i % 2) * 2;
797       int py = LY + (i / 2) * 2;
798       int dx = px % TILEX;
799       int dy = py % TILEY;
800       int lx = (px + TILEX) / TILEX - 1;  // ...+TILEX...-1 to get correct
801       int ly = (py + TILEY) / TILEY - 1;  // negative values!
802       Pixel pixel;
803
804       if (IN_LEV_FIELD(lx, ly))
805       {
806         int element = Feld[lx][ly];
807
808         if (element == EL_EMPTY || element == EL_EXPLODING_TRANSP)
809         {
810           pixel = 0;
811         }
812         else if (IS_WALL(element) || IS_WALL_CHANGING(element))
813         {
814           int pos = dy / MINI_TILEY * 2 + dx / MINI_TILEX;
815
816           pixel = ((element & (1 << pos)) ? 1 : 0);
817         }
818         else
819         {
820           int pos = getMaskFromElement(element) - IMG_MM_MASK_MCDUFFIN_RIGHT;
821
822           pixel = (mm_masks[pos][dy / 2][dx / 2] == 'X' ? 1 : 0);
823         }
824       }
825       else
826       {
827         pixel = (cSX + px < REAL_SX || cSX + px >= REAL_SX + FULL_SXSIZE ||
828                  cSY + py < REAL_SY || cSY + py >= REAL_SY + FULL_SYSIZE);
829       }
830
831       if ((Sign[laser.current_angle] & (1 << i)) && pixel)
832         hit_mask |= (1 << i);
833     }
834
835     if (hit_mask == HIT_MASK_NO_HIT)
836     {
837       // hit nothing -- go on with another step
838       LX += XS;
839       LY += YS;
840     }
841   }
842
843   return hit_mask;
844 }
845
846 void ScanLaser(void)
847 {
848   int element;
849   int end = 0, rf = laser.num_edges;
850
851   // do not scan laser again after the game was lost for whatever reason
852   if (game_mm.game_over)
853     return;
854
855   laser.overloaded = FALSE;
856   laser.stops_inside_element = FALSE;
857
858   DrawLaser(0, DL_LASER_ENABLED);
859
860 #if 0
861   printf("Start scanning with LX == %d, LY == %d, XS == %d, YS == %d\n",
862          LX, LY, XS, YS);
863 #endif
864
865   while (1)
866   {
867     int hit_mask;
868
869     if (laser.num_edges > MAX_LASER_LEN || laser.num_damages > MAX_LASER_LEN)
870     {
871       end = 1;
872       laser.overloaded = TRUE;
873
874       break;
875     }
876
877     hit_mask = ScanPixel();
878
879 #if 0
880     printf("Hit something at LX == %d, LY == %d, XS == %d, YS == %d\n",
881            LX, LY, XS, YS);
882 #endif
883
884     // hit something -- check out what it was
885     ELX = (LX + XS) / TILEX;
886     ELY = (LY + YS) / TILEY;
887
888 #if 0
889     printf("hit_mask (1) == '%x' (%d, %d) (%d, %d)\n",
890            hit_mask, LX, LY, ELX, ELY);
891 #endif
892
893     if (!IN_LEV_FIELD(ELX, ELY) || !IN_PIX_FIELD(LX, LY))
894     {
895       element = EL_EMPTY;
896       laser.dest_element = element;
897
898       break;
899     }
900
901     if (hit_mask == (HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT))
902     {
903       /* we have hit the top-right and bottom-left element --
904          choose the bottom-left one */
905       /* !!! THIS CAN BE DONE MORE INTELLIGENTLY, FOR EXAMPLE, IF ONE
906          ELEMENT WAS STEEL AND THE OTHER ONE WAS ICE => ALWAYS CHOOSE
907          THE ICE AND MELT IT AWAY INSTEAD OF OVERLOADING LASER !!! */
908       ELX = (LX - 2) / TILEX;
909       ELY = (LY + 2) / TILEY;
910     }
911
912     if (hit_mask == (HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT))
913     {
914       /* we have hit the top-left and bottom-right element --
915          choose the top-left one */
916       // !!! SEE ABOVE !!!
917       ELX = (LX - 2) / TILEX;
918       ELY = (LY - 2) / TILEY;
919     }
920
921 #if 0
922     printf("hit_mask (2) == '%x' (%d, %d) (%d, %d)\n",
923            hit_mask, LX, LY, ELX, ELY);
924 #endif
925
926     element = Feld[ELX][ELY];
927     laser.dest_element = element;
928
929 #if 0
930     printf("Hit element %d at (%d, %d) [%d, %d] [%d, %d] [%d]\n",
931            element, ELX, ELY,
932            LX, LY,
933            LX % TILEX, LY % TILEY,
934            hit_mask);
935 #endif
936
937 #if 0
938     if (!IN_LEV_FIELD(ELX, ELY))
939       printf("WARNING! (1) %d, %d (%d)\n", ELX, ELY, element);
940 #endif
941
942     if (element == EL_EMPTY)
943     {
944       if (!HitOnlyAnEdge(element, hit_mask))
945         break;
946     }
947     else if (element == EL_FUSE_ON)
948     {
949       if (HitPolarizer(element, hit_mask))
950         break;
951     }
952     else if (IS_GRID(element) || IS_DF_GRID(element))
953     {
954       if (HitPolarizer(element, hit_mask))
955         break;
956     }
957     else if (element == EL_BLOCK_STONE || element == EL_BLOCK_WOOD ||
958              element == EL_GATE_STONE || element == EL_GATE_WOOD)
959     {
960       if (HitBlock(element, hit_mask))
961       {
962         rf = 1;
963
964         break;
965       }
966     }
967     else if (IS_MCDUFFIN(element))
968     {
969       if (HitLaserSource(element, hit_mask))
970         break;
971     }
972     else if ((element >= EL_EXIT_CLOSED && element <= EL_EXIT_OPEN) ||
973              IS_RECEIVER(element))
974     {
975       if (HitLaserDestination(element, hit_mask))
976         break;
977     }
978     else if (IS_WALL(element))
979     {
980       if (IS_WALL_STEEL(element) || IS_DF_WALL_STEEL(element))
981       {
982         if (HitReflectingWalls(element, hit_mask))
983           break;
984       }
985       else
986       {
987         if (HitAbsorbingWalls(element, hit_mask))
988           break;
989       }
990     }
991     else
992     {
993       if (HitElement(element, hit_mask))
994         break;
995     }
996
997     if (rf)
998       DrawLaser(rf - 1, DL_LASER_ENABLED);
999     rf = laser.num_edges;
1000   }
1001
1002 #if 0
1003   if (laser.dest_element != Feld[ELX][ELY])
1004   {
1005     printf("ALARM: laser.dest_element == %d, Feld[ELX][ELY] == %d\n",
1006            laser.dest_element, Feld[ELX][ELY]);
1007   }
1008 #endif
1009
1010   if (!end && !laser.stops_inside_element && !StepBehind())
1011   {
1012 #if 0
1013     printf("ScanLaser: Go one step back\n");
1014 #endif
1015
1016     LX -= XS;
1017     LY -= YS;
1018
1019     AddLaserEdge(LX, LY);
1020   }
1021
1022   if (rf)
1023     DrawLaser(rf - 1, DL_LASER_ENABLED);
1024
1025   Ct = CT = FrameCounter;
1026
1027 #if 0
1028     if (!IN_LEV_FIELD(ELX, ELY))
1029       printf("WARNING! (2) %d, %d\n", ELX, ELY);
1030 #endif
1031 }
1032
1033 static void DrawLaserExt(int start_edge, int num_edges, int mode)
1034 {
1035   int element;
1036   int elx, ely;
1037
1038 #if 0
1039   printf("DrawLaserExt: start_edge, num_edges, mode == %d, %d, %d\n",
1040          start_edge, num_edges, mode);
1041 #endif
1042
1043   if (start_edge < 0)
1044   {
1045     Error(ERR_WARN, "DrawLaserExt: start_edge < 0");
1046
1047     return;
1048   }
1049
1050   if (num_edges < 0)
1051   {
1052     Error(ERR_WARN, "DrawLaserExt: num_edges < 0");
1053
1054     return;
1055   }
1056
1057 #if 0
1058   if (mode == DL_LASER_DISABLED)
1059   {
1060     printf("DrawLaser: Delete laser from edge %d\n", start_edge);
1061   }
1062 #endif
1063
1064   // now draw the laser to the backbuffer and (if enabled) to the screen
1065   DrawLaserLines(&laser.edge[start_edge], num_edges, mode);
1066
1067   redraw_mask |= REDRAW_FIELD;
1068
1069   if (mode == DL_LASER_ENABLED)
1070     return;
1071
1072   // after the laser was deleted, the "damaged" graphics must be restored
1073   if (laser.num_damages)
1074   {
1075     int damage_start = 0;
1076     int i;
1077
1078     // determine the starting edge, from which graphics need to be restored
1079     if (start_edge > 0)
1080     {
1081       for (i = 0; i < laser.num_damages; i++)
1082       {
1083         if (laser.damage[i].edge == start_edge + 1)
1084         {
1085           damage_start = i;
1086
1087           break;
1088         }
1089       }
1090     }
1091
1092     // restore graphics from this starting edge to the end of damage list
1093     for (i = damage_start; i < laser.num_damages; i++)
1094     {
1095       int lx = laser.damage[i].x;
1096       int ly = laser.damage[i].y;
1097       int element = Feld[lx][ly];
1098
1099       if (Hit[lx][ly] == laser.damage[i].edge)
1100         if (!((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1101                i == damage_start))
1102           Hit[lx][ly] = 0;
1103       if (Box[lx][ly] == laser.damage[i].edge)
1104         Box[lx][ly] = 0;
1105
1106       if (IS_DRAWABLE(element))
1107         DrawField_MM(lx, ly);
1108     }
1109
1110     elx = laser.damage[damage_start].x;
1111     ely = laser.damage[damage_start].y;
1112     element = Feld[elx][ely];
1113
1114 #if 0
1115     if (IS_BEAMER(element))
1116     {
1117       int i;
1118
1119       for (i = 0; i < laser.num_beamers; i++)
1120         printf("-> %d\n", laser.beamer_edge[i]);
1121       printf("DrawLaserExt: IS_BEAMER: [%d]: Hit[%d][%d] == %d [%d]\n",
1122              mode, elx, ely, Hit[elx][ely], start_edge);
1123       printf("DrawLaserExt: IS_BEAMER: %d / %d\n",
1124              get_element_angle(element), laser.damage[damage_start].angle);
1125     }
1126 #endif
1127
1128     if ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1129         laser.num_beamers > 0 &&
1130         start_edge == laser.beamer_edge[laser.num_beamers - 1])
1131     {
1132       // element is outgoing beamer
1133       laser.num_damages = damage_start + 1;
1134
1135       if (IS_BEAMER(element))
1136         laser.current_angle = get_element_angle(element);
1137     }
1138     else
1139     {
1140       // element is incoming beamer or other element
1141       laser.num_damages = damage_start;
1142       laser.current_angle = laser.damage[laser.num_damages].angle;
1143     }
1144   }
1145   else
1146   {
1147     // no damages but McDuffin himself (who needs to be redrawn anyway)
1148
1149     elx = laser.start_edge.x;
1150     ely = laser.start_edge.y;
1151     element = Feld[elx][ely];
1152   }
1153
1154   laser.num_edges = start_edge + 1;
1155   if (start_edge == 0)
1156     laser.current_angle = laser.start_angle;
1157
1158   LX = laser.edge[start_edge].x - cSX2;
1159   LY = laser.edge[start_edge].y - cSY2;
1160   XS = 2 * Step[laser.current_angle].x;
1161   YS = 2 * Step[laser.current_angle].y;
1162
1163 #if 0
1164   printf("DrawLaser: Set (LX, LY) to (%d, %d) [%d]\n",
1165          LX, LY, element);
1166 #endif
1167
1168   if (start_edge > 0)
1169   {
1170     if (IS_BEAMER(element) ||
1171         IS_FIBRE_OPTIC(element) ||
1172         IS_PACMAN(element) ||
1173         IS_POLAR(element) ||
1174         IS_POLAR_CROSS(element) ||
1175         element == EL_FUSE_ON)
1176     {
1177       int step_size;
1178
1179 #if 0
1180       printf("element == %d\n", element);
1181 #endif
1182
1183       if (IS_22_5_ANGLE(laser.current_angle))   // neither 90° nor 45° angle
1184         step_size = ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) ? 4 : 3);
1185       else
1186         step_size = 8;
1187
1188       if (IS_POLAR(element) || IS_POLAR_CROSS(element) ||
1189           ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1190            (laser.num_beamers == 0 ||
1191             start_edge != laser.beamer_edge[laser.num_beamers - 1])))
1192       {
1193         // element is incoming beamer or other element
1194         step_size = -step_size;
1195         laser.num_edges--;
1196       }
1197
1198 #if 0
1199       if (IS_BEAMER(element))
1200       {
1201         printf("start_edge == %d, laser.beamer_edge == %d\n",
1202                start_edge, laser.beamer_edge);
1203       }
1204 #endif
1205
1206       LX += step_size * XS;
1207       LY += step_size * YS;
1208     }
1209     else if (element != EL_EMPTY)
1210     {
1211       LX -= 3 * XS;
1212       LY -= 3 * YS;
1213       laser.num_edges--;
1214     }
1215   }
1216
1217 #if 0
1218   printf("DrawLaser: Finally: (LX, LY) to (%d, %d) [%d]\n",
1219          LX, LY, element);
1220 #endif
1221 }
1222
1223 void DrawLaser(int start_edge, int mode)
1224 {
1225   if (laser.num_edges - start_edge < 0)
1226   {
1227     Error(ERR_WARN, "DrawLaser: laser.num_edges - start_edge < 0");
1228
1229     return;
1230   }
1231
1232   // check if laser is interrupted by beamer element
1233   if (laser.num_beamers > 0 &&
1234       start_edge < laser.beamer_edge[laser.num_beamers - 1])
1235   {
1236     if (mode == DL_LASER_ENABLED)
1237     {
1238       int i;
1239       int tmp_start_edge = start_edge;
1240
1241       // draw laser segments forward from the start to the last beamer
1242       for (i = 0; i < laser.num_beamers; i++)
1243       {
1244         int tmp_num_edges = laser.beamer_edge[i] - tmp_start_edge;
1245
1246         if (tmp_num_edges <= 0)
1247           continue;
1248
1249 #if 0
1250         printf("DrawLaser: DL_LASER_ENABLED: i==%d: %d, %d\n",
1251                i, laser.beamer_edge[i], tmp_start_edge);
1252 #endif
1253
1254         DrawLaserExt(tmp_start_edge, tmp_num_edges, DL_LASER_ENABLED);
1255
1256         tmp_start_edge = laser.beamer_edge[i];
1257       }
1258
1259       // draw last segment from last beamer to the end
1260       DrawLaserExt(tmp_start_edge, laser.num_edges - tmp_start_edge,
1261                    DL_LASER_ENABLED);
1262     }
1263     else
1264     {
1265       int i;
1266       int last_num_edges = laser.num_edges;
1267       int num_beamers = laser.num_beamers;
1268
1269       // delete laser segments backward from the end to the first beamer
1270       for (i = num_beamers - 1; i >= 0; i--)
1271       {
1272         int tmp_num_edges = last_num_edges - laser.beamer_edge[i];
1273
1274         if (laser.beamer_edge[i] - start_edge <= 0)
1275           break;
1276
1277         DrawLaserExt(laser.beamer_edge[i], tmp_num_edges, DL_LASER_DISABLED);
1278
1279         last_num_edges = laser.beamer_edge[i];
1280         laser.num_beamers--;
1281       }
1282
1283 #if 0
1284       if (last_num_edges - start_edge <= 0)
1285         printf("DrawLaser: DL_LASER_DISABLED: %d, %d\n",
1286                last_num_edges, start_edge);
1287 #endif
1288
1289       // special case when rotating first beamer: delete laser edge on beamer
1290       // (but do not start scanning on previous edge to prevent mirror sound)
1291       if (last_num_edges - start_edge == 1 && start_edge > 0)
1292         DrawLaserLines(&laser.edge[start_edge - 1], 2, DL_LASER_DISABLED);
1293
1294       // delete first segment from start to the first beamer
1295       DrawLaserExt(start_edge, last_num_edges - start_edge, DL_LASER_DISABLED);
1296     }
1297   }
1298   else
1299   {
1300     DrawLaserExt(start_edge, laser.num_edges - start_edge, mode);
1301   }
1302
1303   game_mm.laser_enabled = mode;
1304 }
1305
1306 void DrawLaser_MM(void)
1307 {
1308   DrawLaser(0, game_mm.laser_enabled);
1309 }
1310
1311 boolean HitElement(int element, int hit_mask)
1312 {
1313   if (HitOnlyAnEdge(element, hit_mask))
1314     return FALSE;
1315
1316   if (IS_MOVING(ELX, ELY) || IS_BLOCKED(ELX, ELY))
1317     element = MovingOrBlocked2Element_MM(ELX, ELY);
1318
1319 #if 0
1320   printf("HitElement (1): element == %d\n", element);
1321 #endif
1322
1323 #if 0
1324   if ((ELX * TILEX + 14 - LX) * YS == (ELY * TILEY + 14 - LY) * XS)
1325     printf("HitElement (%d): EXACT MATCH @ (%d, %d)\n", element, ELX, ELY);
1326   else
1327     printf("HitElement (%d): FUZZY MATCH @ (%d, %d)\n", element, ELX, ELY);
1328 #endif
1329
1330   AddDamagedField(ELX, ELY);
1331
1332   // this is more precise: check if laser would go through the center
1333   if ((ELX * TILEX + 14 - LX) * YS != (ELY * TILEY + 14 - LY) * XS)
1334   {
1335     // skip the whole element before continuing the scan
1336     do
1337     {
1338       LX += XS;
1339       LY += YS;
1340     }
1341     while (ELX == LX/TILEX && ELY == LY/TILEY && LX > 0 && LY > 0);
1342
1343     if (LX/TILEX > ELX || LY/TILEY > ELY)
1344     {
1345       /* skipping scan positions to the right and down skips one scan
1346          position too much, because this is only the top left scan position
1347          of totally four scan positions (plus one to the right, one to the
1348          bottom and one to the bottom right) */
1349
1350       LX -= XS;
1351       LY -= YS;
1352     }
1353
1354     return FALSE;
1355   }
1356
1357 #if 0
1358   printf("HitElement (2): element == %d\n", element);
1359 #endif
1360
1361   if (LX + 5 * XS < 0 ||
1362       LY + 5 * YS < 0)
1363   {
1364     LX += 2 * XS;
1365     LY += 2 * YS;
1366
1367     return FALSE;
1368   }
1369
1370 #if 0
1371   printf("HitElement (3): element == %d\n", element);
1372 #endif
1373
1374   if (IS_POLAR(element) &&
1375       ((element - EL_POLAR_START) % 2 ||
1376        (element - EL_POLAR_START) / 2 != laser.current_angle % 8))
1377   {
1378     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1379
1380     laser.num_damages--;
1381
1382     return TRUE;
1383   }
1384
1385   if (IS_POLAR_CROSS(element) &&
1386       (element - EL_POLAR_CROSS_START) != laser.current_angle % 4)
1387   {
1388     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1389
1390     laser.num_damages--;
1391
1392     return TRUE;
1393   }
1394
1395   if (!IS_BEAMER(element) &&
1396       !IS_FIBRE_OPTIC(element) &&
1397       !IS_GRID_WOOD(element) &&
1398       element != EL_FUEL_EMPTY)
1399   {
1400 #if 0
1401     if ((ELX * TILEX + 14 - LX) * YS == (ELY * TILEY + 14 - LY) * XS)
1402       printf("EXACT MATCH @ (%d, %d)\n", ELX, ELY);
1403     else
1404       printf("FUZZY MATCH @ (%d, %d)\n", ELX, ELY);
1405 #endif
1406
1407     LX = ELX * TILEX + 14;
1408     LY = ELY * TILEY + 14;
1409
1410     AddLaserEdge(LX, LY);
1411   }
1412
1413   if (IS_MIRROR(element) ||
1414       IS_MIRROR_FIXED(element) ||
1415       IS_POLAR(element) ||
1416       IS_POLAR_CROSS(element) ||
1417       IS_DF_MIRROR(element) ||
1418       IS_DF_MIRROR_AUTO(element) ||
1419       element == EL_PRISM ||
1420       element == EL_REFRACTOR)
1421   {
1422     int current_angle = laser.current_angle;
1423     int step_size;
1424
1425     laser.num_damages--;
1426
1427     AddDamagedField(ELX, ELY);
1428
1429     laser.damage[laser.num_damages - 1].is_mirror = TRUE;
1430
1431     if (!Hit[ELX][ELY])
1432       Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1433
1434     if (IS_MIRROR(element) ||
1435         IS_MIRROR_FIXED(element) ||
1436         IS_DF_MIRROR(element) ||
1437         IS_DF_MIRROR_AUTO(element))
1438       laser.current_angle = get_mirrored_angle(laser.current_angle,
1439                                                get_element_angle(element));
1440
1441     if (element == EL_PRISM || element == EL_REFRACTOR)
1442       laser.current_angle = RND(16);
1443
1444     XS = 2 * Step[laser.current_angle].x;
1445     YS = 2 * Step[laser.current_angle].y;
1446
1447     if (!IS_22_5_ANGLE(laser.current_angle))    // 90° or 45° angle
1448       step_size = 8;
1449     else
1450       step_size = 4;
1451
1452     LX += step_size * XS;
1453     LY += step_size * YS;
1454
1455 #if 0
1456     // draw sparkles on mirror
1457     if ((IS_MIRROR(element) || IS_MIRROR_FIXED(element)) &&
1458         current_angle != laser.current_angle)
1459     {
1460       MoveSprite(vp, &Pfeil[2], 4 + 16 * ELX, 5 + 16 * ELY + 1);
1461     }
1462 #endif
1463
1464     if ((!IS_POLAR(element) && !IS_POLAR_CROSS(element)) &&
1465         current_angle != laser.current_angle)
1466       PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1467
1468     laser.overloaded =
1469       (get_opposite_angle(laser.current_angle) ==
1470        laser.damage[laser.num_damages - 1].angle ? TRUE : FALSE);
1471
1472     return (laser.overloaded ? TRUE : FALSE);
1473   }
1474
1475   if (element == EL_FUEL_FULL)
1476   {
1477     laser.stops_inside_element = TRUE;
1478
1479     return TRUE;
1480   }
1481
1482   if (element == EL_BOMB || element == EL_MINE)
1483   {
1484     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1485
1486     if (element == EL_MINE)
1487       laser.overloaded = TRUE;
1488   }
1489
1490   if (element == EL_KETTLE ||
1491       element == EL_CELL ||
1492       element == EL_KEY ||
1493       element == EL_LIGHTBALL ||
1494       element == EL_PACMAN ||
1495       IS_PACMAN(element))
1496   {
1497     if (!IS_PACMAN(element))
1498       Bang_MM(ELX, ELY);
1499
1500     if (element == EL_PACMAN)
1501       Bang_MM(ELX, ELY);
1502
1503     if (element == EL_KETTLE || element == EL_CELL)
1504     {
1505       if (game_mm.kettles_still_needed > 0)
1506         game_mm.kettles_still_needed--;
1507
1508       game.snapshot.collected_item = TRUE;
1509
1510       if (game_mm.kettles_still_needed == 0)
1511       {
1512         CheckExitMM();
1513
1514         DrawLaser(0, DL_LASER_ENABLED);
1515       }
1516     }
1517     else if (element == EL_KEY)
1518     {
1519       game_mm.num_keys++;
1520     }
1521     else if (IS_PACMAN(element))
1522     {
1523       DeletePacMan(ELX, ELY);
1524     }
1525
1526     RaiseScoreElement_MM(element);
1527
1528     return FALSE;
1529   }
1530
1531   if (element == EL_LIGHTBULB_OFF || element == EL_LIGHTBULB_ON)
1532   {
1533     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1534
1535     DrawLaser(0, DL_LASER_ENABLED);
1536
1537     if (Feld[ELX][ELY] == EL_LIGHTBULB_OFF)
1538     {
1539       Feld[ELX][ELY] = EL_LIGHTBULB_ON;
1540       game_mm.lights_still_needed--;
1541     }
1542     else
1543     {
1544       Feld[ELX][ELY] = EL_LIGHTBULB_OFF;
1545       game_mm.lights_still_needed++;
1546     }
1547
1548     DrawField_MM(ELX, ELY);
1549     DrawLaser(0, DL_LASER_ENABLED);
1550
1551     /*
1552     BackToFront();
1553     */
1554     laser.stops_inside_element = TRUE;
1555
1556     return TRUE;
1557   }
1558
1559 #if 0
1560   printf("HitElement (4): element == %d\n", element);
1561 #endif
1562
1563   if ((IS_BEAMER(element) || IS_FIBRE_OPTIC(element)) &&
1564       laser.num_beamers < MAX_NUM_BEAMERS &&
1565       laser.beamer[BEAMER_NR(element)][1].num)
1566   {
1567     int beamer_angle = get_element_angle(element);
1568     int beamer_nr = BEAMER_NR(element);
1569     int step_size;
1570
1571 #if 0
1572   printf("HitElement (BEAMER): element == %d\n", element);
1573 #endif
1574
1575     laser.num_damages--;
1576
1577     if (IS_FIBRE_OPTIC(element) ||
1578         laser.current_angle == get_opposite_angle(beamer_angle))
1579     {
1580       int pos;
1581
1582       LX = ELX * TILEX + 14;
1583       LY = ELY * TILEY + 14;
1584
1585       AddLaserEdge(LX, LY);
1586       AddDamagedField(ELX, ELY);
1587
1588       laser.damage[laser.num_damages - 1].is_mirror = TRUE;
1589
1590       if (!Hit[ELX][ELY])
1591         Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1592
1593       pos = (ELX == laser.beamer[beamer_nr][0].x &&
1594              ELY == laser.beamer[beamer_nr][0].y ? 1 : 0);
1595       ELX = laser.beamer[beamer_nr][pos].x;
1596       ELY = laser.beamer[beamer_nr][pos].y;
1597       LX = ELX * TILEX + 14;
1598       LY = ELY * TILEY + 14;
1599
1600       if (IS_BEAMER(element))
1601       {
1602         laser.current_angle = get_element_angle(Feld[ELX][ELY]);
1603         XS = 2 * Step[laser.current_angle].x;
1604         YS = 2 * Step[laser.current_angle].y;
1605       }
1606
1607       laser.beamer_edge[laser.num_beamers] = laser.num_edges;
1608
1609       AddLaserEdge(LX, LY);
1610       AddDamagedField(ELX, ELY);
1611
1612       laser.damage[laser.num_damages - 1].is_mirror = TRUE;
1613
1614       if (!Hit[ELX][ELY])
1615         Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1616
1617       if (laser.current_angle == (laser.current_angle >> 1) << 1)
1618         step_size = 8;
1619       else
1620         step_size = 4;
1621
1622       LX += step_size * XS;
1623       LY += step_size * YS;
1624
1625       laser.num_beamers++;
1626
1627       return FALSE;
1628     }
1629   }
1630
1631   return TRUE;
1632 }
1633
1634 boolean HitOnlyAnEdge(int element, int hit_mask)
1635 {
1636   // check if the laser hit only the edge of an element and, if so, go on
1637
1638 #if 0
1639   printf("LX, LY, hit_mask == %d, %d, %d\n", LX, LY, hit_mask);
1640 #endif
1641
1642   if ((hit_mask == HIT_MASK_TOPLEFT ||
1643        hit_mask == HIT_MASK_TOPRIGHT ||
1644        hit_mask == HIT_MASK_BOTTOMLEFT ||
1645        hit_mask == HIT_MASK_BOTTOMRIGHT) &&
1646       laser.current_angle % 4)                  // angle is not 90°
1647   {
1648     int dx, dy;
1649
1650     if (hit_mask == HIT_MASK_TOPLEFT)
1651     {
1652       dx = -1;
1653       dy = -1;
1654     }
1655     else if (hit_mask == HIT_MASK_TOPRIGHT)
1656     {
1657       dx = +1;
1658       dy = -1;
1659     }
1660     else if (hit_mask == HIT_MASK_BOTTOMLEFT)
1661     {
1662       dx = -1;
1663       dy = +1;
1664     }
1665     else // (hit_mask == HIT_MASK_BOTTOMRIGHT)
1666     {
1667       dx = +1;
1668       dy = +1;
1669     }
1670
1671     AddDamagedField((LX + 2 * dx) / TILEX, (LY + 2 * dy) / TILEY);
1672
1673     LX += XS;
1674     LY += YS;
1675
1676 #if 0
1677     printf("[HitOnlyAnEdge() == TRUE]\n");
1678 #endif
1679
1680     return TRUE;
1681   }
1682
1683 #if 0
1684     printf("[HitOnlyAnEdge() == FALSE]\n");
1685 #endif
1686
1687   return FALSE;
1688 }
1689
1690 boolean HitPolarizer(int element, int hit_mask)
1691 {
1692   if (HitOnlyAnEdge(element, hit_mask))
1693     return FALSE;
1694
1695   if (IS_DF_GRID(element))
1696   {
1697     int grid_angle = get_element_angle(element);
1698
1699 #if 0
1700     printf("HitPolarizer: angle: grid == %d, laser == %d\n",
1701            grid_angle, laser.current_angle);
1702 #endif
1703
1704     AddLaserEdge(LX, LY);
1705     AddDamagedField(ELX, ELY);
1706
1707     if (!Hit[ELX][ELY])
1708       Hit[ELX][ELY] = laser.damage[laser.num_damages - 1].edge;
1709
1710     if (laser.current_angle == grid_angle ||
1711         laser.current_angle == get_opposite_angle(grid_angle))
1712     {
1713       // skip the whole element before continuing the scan
1714       do
1715       {
1716         LX += XS;
1717         LY += YS;
1718       }
1719       while (ELX == LX/TILEX && ELY == LY/TILEY && LX > 0 && LY > 0);
1720
1721       if (LX/TILEX > ELX || LY/TILEY > ELY)
1722       {
1723         /* skipping scan positions to the right and down skips one scan
1724            position too much, because this is only the top left scan position
1725            of totally four scan positions (plus one to the right, one to the
1726            bottom and one to the bottom right) */
1727
1728         LX -= XS;
1729         LY -= YS;
1730       }
1731
1732       AddLaserEdge(LX, LY);
1733
1734       LX += XS;
1735       LY += YS;
1736
1737 #if 0
1738       printf("HitPolarizer: LX, LY == %d, %d [%d, %d] [%d, %d]\n",
1739              LX, LY,
1740              LX / TILEX, LY / TILEY,
1741              LX % TILEX, LY % TILEY);
1742 #endif
1743
1744       return FALSE;
1745     }
1746     else if (IS_GRID_STEEL_FIXED(element) || IS_GRID_STEEL_AUTO(element))
1747     {
1748       return HitReflectingWalls(element, hit_mask);
1749     }
1750     else
1751     {
1752       return HitAbsorbingWalls(element, hit_mask);
1753     }
1754   }
1755   else if (IS_GRID_STEEL(element))
1756   {
1757     return HitReflectingWalls(element, hit_mask);
1758   }
1759   else  // IS_GRID_WOOD
1760   {
1761     return HitAbsorbingWalls(element, hit_mask);
1762   }
1763
1764   return TRUE;
1765 }
1766
1767 boolean HitBlock(int element, int hit_mask)
1768 {
1769   boolean check = FALSE;
1770
1771   if ((element == EL_GATE_STONE || element == EL_GATE_WOOD) &&
1772       game_mm.num_keys == 0)
1773     check = TRUE;
1774
1775   if (element == EL_BLOCK_STONE || element == EL_BLOCK_WOOD)
1776   {
1777     int i, x, y;
1778     int ex = ELX * TILEX + 14;
1779     int ey = ELY * TILEY + 14;
1780
1781     check = TRUE;
1782
1783     for (i = 1; i < 32; i++)
1784     {
1785       x = LX + i * XS;
1786       y = LY + i * YS;
1787
1788       if ((x == ex || x == ex + 1) && (y == ey || y == ey + 1))
1789         check = FALSE;
1790     }
1791   }
1792
1793   if (check && (element == EL_BLOCK_WOOD || element == EL_GATE_WOOD))
1794     return HitAbsorbingWalls(element, hit_mask);
1795
1796   if (check)
1797   {
1798     AddLaserEdge(LX - XS, LY - YS);
1799     AddDamagedField(ELX, ELY);
1800
1801     if (!Box[ELX][ELY])
1802       Box[ELX][ELY] = laser.num_edges;
1803
1804     return HitReflectingWalls(element, hit_mask);
1805   }
1806
1807   if (element == EL_GATE_STONE || element == EL_GATE_WOOD)
1808   {
1809     int xs = XS / 2, ys = YS / 2;
1810     int hit_mask_diagonal1 = HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT;
1811     int hit_mask_diagonal2 = HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT;
1812
1813     if ((hit_mask & hit_mask_diagonal1) == hit_mask_diagonal1 ||
1814         (hit_mask & hit_mask_diagonal2) == hit_mask_diagonal2)
1815     {
1816       laser.overloaded = (element == EL_GATE_STONE);
1817
1818       return TRUE;
1819     }
1820
1821     if (ABS(xs) == 1 && ABS(ys) == 1 &&
1822         (hit_mask == HIT_MASK_TOP ||
1823          hit_mask == HIT_MASK_LEFT ||
1824          hit_mask == HIT_MASK_RIGHT ||
1825          hit_mask == HIT_MASK_BOTTOM))
1826       AddDamagedField(ELX - xs * (hit_mask == HIT_MASK_TOP ||
1827                                   hit_mask == HIT_MASK_BOTTOM),
1828                       ELY - ys * (hit_mask == HIT_MASK_LEFT ||
1829                                   hit_mask == HIT_MASK_RIGHT));
1830     AddLaserEdge(LX, LY);
1831
1832     Bang_MM(ELX, ELY);
1833
1834     game_mm.num_keys--;
1835
1836     if (element == EL_GATE_STONE && Box[ELX][ELY])
1837     {
1838       DrawLaser(Box[ELX][ELY] - 1, DL_LASER_DISABLED);
1839       /*
1840       BackToFront();
1841       */
1842       ScanLaser();
1843
1844       return TRUE;
1845     }
1846
1847     return FALSE;
1848   }
1849
1850   if (element == EL_BLOCK_STONE || element == EL_BLOCK_WOOD)
1851   {
1852     int xs = XS / 2, ys = YS / 2;
1853     int hit_mask_diagonal1 = HIT_MASK_TOPRIGHT | HIT_MASK_BOTTOMLEFT;
1854     int hit_mask_diagonal2 = HIT_MASK_TOPLEFT | HIT_MASK_BOTTOMRIGHT;
1855
1856     if ((hit_mask & hit_mask_diagonal1) == hit_mask_diagonal1 ||
1857         (hit_mask & hit_mask_diagonal2) == hit_mask_diagonal2)
1858     {
1859       laser.overloaded = (element == EL_BLOCK_STONE);
1860
1861       return TRUE;
1862     }
1863
1864     if (ABS(xs) == 1 && ABS(ys) == 1 &&
1865         (hit_mask == HIT_MASK_TOP ||
1866          hit_mask == HIT_MASK_LEFT ||
1867          hit_mask == HIT_MASK_RIGHT ||
1868          hit_mask == HIT_MASK_BOTTOM))
1869       AddDamagedField(ELX - xs * (hit_mask == HIT_MASK_TOP ||
1870                                   hit_mask == HIT_MASK_BOTTOM),
1871                       ELY - ys * (hit_mask == HIT_MASK_LEFT ||
1872                                   hit_mask == HIT_MASK_RIGHT));
1873     AddDamagedField(ELX, ELY);
1874
1875     LX = ELX * TILEX + 14;
1876     LY = ELY * TILEY + 14;
1877
1878     AddLaserEdge(LX, LY);
1879
1880     laser.stops_inside_element = TRUE;
1881
1882     return TRUE;
1883   }
1884
1885   return TRUE;
1886 }
1887
1888 boolean HitLaserSource(int element, int hit_mask)
1889 {
1890   if (HitOnlyAnEdge(element, hit_mask))
1891     return FALSE;
1892
1893   PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1894
1895   laser.overloaded = TRUE;
1896
1897   return TRUE;
1898 }
1899
1900 boolean HitLaserDestination(int element, int hit_mask)
1901 {
1902   if (HitOnlyAnEdge(element, hit_mask))
1903     return FALSE;
1904
1905   if (element != EL_EXIT_OPEN &&
1906       !(IS_RECEIVER(element) &&
1907         game_mm.kettles_still_needed == 0 &&
1908         laser.current_angle == get_opposite_angle(get_element_angle(element))))
1909   {
1910     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1911
1912     return TRUE;
1913   }
1914
1915   if (IS_RECEIVER(element) ||
1916       (IS_22_5_ANGLE(laser.current_angle) &&
1917        (ELX != (LX + 6 * XS) / TILEX ||
1918         ELY != (LY + 6 * YS) / TILEY ||
1919         LX + 6 * XS < 0 ||
1920         LY + 6 * YS < 0)))
1921   {
1922     LX -= XS;
1923     LY -= YS;
1924   }
1925   else
1926   {
1927     LX = ELX * TILEX + 14;
1928     LY = ELY * TILEY + 14;
1929
1930     laser.stops_inside_element = TRUE;
1931   }
1932
1933   AddLaserEdge(LX, LY);
1934   AddDamagedField(ELX, ELY);
1935
1936   if (game_mm.lights_still_needed == 0)
1937   {
1938     game_mm.level_solved = TRUE;
1939
1940     SetTileCursorActive(FALSE);
1941   }
1942
1943   return TRUE;
1944 }
1945
1946 boolean HitReflectingWalls(int element, int hit_mask)
1947 {
1948   // check if laser hits side of a wall with an angle that is not 90°
1949   if (!IS_90_ANGLE(laser.current_angle) && (hit_mask == HIT_MASK_TOP ||
1950                                             hit_mask == HIT_MASK_LEFT ||
1951                                             hit_mask == HIT_MASK_RIGHT ||
1952                                             hit_mask == HIT_MASK_BOTTOM))
1953   {
1954     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
1955
1956     LX -= XS;
1957     LY -= YS;
1958
1959     if (!IS_DF_GRID(element))
1960       AddLaserEdge(LX, LY);
1961
1962     // check if laser hits wall with an angle of 45°
1963     if (!IS_22_5_ANGLE(laser.current_angle))
1964     {
1965       if (hit_mask == HIT_MASK_TOP || hit_mask == HIT_MASK_BOTTOM)
1966       {
1967         LX += 2 * XS;
1968         laser.current_angle = get_mirrored_angle(laser.current_angle,
1969                                                  ANG_MIRROR_0);
1970       }
1971       else      // hit_mask == HIT_MASK_LEFT || hit_mask == HIT_MASK_RIGHT
1972       {
1973         LY += 2 * YS;
1974         laser.current_angle = get_mirrored_angle(laser.current_angle,
1975                                                  ANG_MIRROR_90);
1976       }
1977
1978       AddLaserEdge(LX, LY);
1979
1980       XS = 2 * Step[laser.current_angle].x;
1981       YS = 2 * Step[laser.current_angle].y;
1982
1983       return FALSE;
1984     }
1985     else if (hit_mask == HIT_MASK_TOP || hit_mask == HIT_MASK_BOTTOM)
1986     {
1987       laser.current_angle = get_mirrored_angle(laser.current_angle,
1988                                                ANG_MIRROR_0);
1989       if (ABS(XS) == 4)
1990       {
1991         LX += 2 * XS;
1992         if (!IS_DF_GRID(element))
1993           AddLaserEdge(LX, LY);
1994       }
1995       else
1996       {
1997         LX += XS;
1998         if (!IS_DF_GRID(element))
1999           AddLaserEdge(LX, LY + YS / 2);
2000
2001         LX += XS;
2002         if (!IS_DF_GRID(element))
2003           AddLaserEdge(LX, LY);
2004       }
2005
2006       YS = 2 * Step[laser.current_angle].y;
2007
2008       return FALSE;
2009     }
2010     else        // hit_mask == HIT_MASK_LEFT || hit_mask == HIT_MASK_RIGHT
2011     {
2012       laser.current_angle = get_mirrored_angle(laser.current_angle,
2013                                                ANG_MIRROR_90);
2014       if (ABS(YS) == 4)
2015       {
2016         LY += 2 * YS;
2017         if (!IS_DF_GRID(element))
2018           AddLaserEdge(LX, LY);
2019       }
2020       else
2021       {
2022         LY += YS;
2023         if (!IS_DF_GRID(element))
2024           AddLaserEdge(LX + XS / 2, LY);
2025
2026         LY += YS;
2027         if (!IS_DF_GRID(element))
2028           AddLaserEdge(LX, LY);
2029       }
2030
2031       XS = 2 * Step[laser.current_angle].x;
2032
2033       return FALSE;
2034     }
2035   }
2036
2037   // reflection at the edge of reflecting DF style wall
2038   if (IS_DF_WALL_STEEL(element) && IS_22_5_ANGLE(laser.current_angle))
2039   {
2040     if (((laser.current_angle == 1 || laser.current_angle == 3) &&
2041          hit_mask == HIT_MASK_TOPRIGHT) ||
2042         ((laser.current_angle == 5 || laser.current_angle == 7) &&
2043          hit_mask == HIT_MASK_TOPLEFT) ||
2044         ((laser.current_angle == 9 || laser.current_angle == 11) &&
2045          hit_mask == HIT_MASK_BOTTOMLEFT) ||
2046         ((laser.current_angle == 13 || laser.current_angle == 15) &&
2047          hit_mask == HIT_MASK_BOTTOMRIGHT))
2048     {
2049       int mirror_angle =
2050         (hit_mask == HIT_MASK_TOPRIGHT || hit_mask == HIT_MASK_BOTTOMLEFT ?
2051          ANG_MIRROR_135 : ANG_MIRROR_45);
2052
2053       PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
2054
2055       AddDamagedField(ELX, ELY);
2056       AddLaserEdge(LX, LY);
2057
2058       laser.current_angle = get_mirrored_angle(laser.current_angle,
2059                                                mirror_angle);
2060       XS = 8 / -XS;
2061       YS = 8 / -YS;
2062
2063       LX += XS;
2064       LY += YS;
2065
2066       AddLaserEdge(LX, LY);
2067
2068       return FALSE;
2069     }
2070   }
2071
2072   // reflection inside an edge of reflecting DF style wall
2073   if (IS_DF_WALL_STEEL(element) && IS_22_5_ANGLE(laser.current_angle))
2074   {
2075     if (((laser.current_angle == 1 || laser.current_angle == 3) &&
2076          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_BOTTOMLEFT)) ||
2077         ((laser.current_angle == 5 || laser.current_angle == 7) &&
2078          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_BOTTOMRIGHT)) ||
2079         ((laser.current_angle == 9 || laser.current_angle == 11) &&
2080          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_TOPRIGHT)) ||
2081         ((laser.current_angle == 13 || laser.current_angle == 15) &&
2082          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_TOPLEFT)))
2083     {
2084       int mirror_angle =
2085         (hit_mask == (HIT_MASK_ALL ^ HIT_MASK_BOTTOMLEFT) ||
2086          hit_mask == (HIT_MASK_ALL ^ HIT_MASK_TOPRIGHT) ?
2087          ANG_MIRROR_135 : ANG_MIRROR_45);
2088
2089       PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
2090
2091       /*
2092       AddDamagedField(ELX, ELY);
2093       */
2094
2095       AddLaserEdge(LX - XS, LY - YS);
2096       AddLaserEdge(LX - XS + (ABS(XS) == 4 ? XS/2 : 0),
2097                    LY - YS + (ABS(YS) == 4 ? YS/2 : 0));
2098
2099       laser.current_angle = get_mirrored_angle(laser.current_angle,
2100                                                mirror_angle);
2101       XS = 8 / -XS;
2102       YS = 8 / -YS;
2103
2104       LX += XS;
2105       LY += YS;
2106
2107       AddLaserEdge(LX, LY);
2108
2109       return FALSE;
2110     }
2111   }
2112
2113   // check if laser hits DF style wall with an angle of 90°
2114   if (IS_DF_WALL(element) && IS_90_ANGLE(laser.current_angle))
2115   {
2116     if ((IS_HORIZ_ANGLE(laser.current_angle) &&
2117          (!(hit_mask & HIT_MASK_TOP) || !(hit_mask & HIT_MASK_BOTTOM))) ||
2118         (IS_VERT_ANGLE(laser.current_angle) &&
2119          (!(hit_mask & HIT_MASK_LEFT) || !(hit_mask & HIT_MASK_RIGHT))))
2120     {
2121       // laser at last step touched nothing or the same side of the wall
2122       if (LX != last_LX || LY != last_LY || hit_mask == last_hit_mask)
2123       {
2124         AddDamagedField(ELX, ELY);
2125
2126         LX += 8 * XS;
2127         LY += 8 * YS;
2128
2129         last_LX = LX;
2130         last_LY = LY;
2131         last_hit_mask = hit_mask;
2132
2133         return FALSE;
2134       }
2135     }
2136   }
2137
2138   if (!HitOnlyAnEdge(element, hit_mask))
2139   {
2140     laser.overloaded = TRUE;
2141
2142     return TRUE;
2143   }
2144
2145   return FALSE;
2146 }
2147
2148 boolean HitAbsorbingWalls(int element, int hit_mask)
2149 {
2150   if (HitOnlyAnEdge(element, hit_mask))
2151     return FALSE;
2152
2153   if (ABS(XS) == 4 &&
2154       (hit_mask == HIT_MASK_LEFT || hit_mask == HIT_MASK_RIGHT))
2155   {
2156     AddLaserEdge(LX - XS, LY - YS);
2157
2158     LX = LX + XS / 2;
2159     LY = LY + YS;
2160   }
2161
2162   if (ABS(YS) == 4 &&
2163       (hit_mask == HIT_MASK_TOP || hit_mask == HIT_MASK_BOTTOM))
2164   {
2165     AddLaserEdge(LX - XS, LY - YS);
2166
2167     LX = LX + XS;
2168     LY = LY + YS / 2;
2169   }
2170
2171   if (IS_WALL_WOOD(element) ||
2172       IS_DF_WALL_WOOD(element) ||
2173       IS_GRID_WOOD(element) ||
2174       IS_GRID_WOOD_FIXED(element) ||
2175       IS_GRID_WOOD_AUTO(element) ||
2176       element == EL_FUSE_ON ||
2177       element == EL_BLOCK_WOOD ||
2178       element == EL_GATE_WOOD)
2179   {
2180     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_HITTING);
2181
2182     return TRUE;
2183   }
2184
2185   if (IS_WALL_ICE(element))
2186   {
2187     int mask;
2188
2189     mask = (LX + XS) / MINI_TILEX - ELX * 2 + 1;    // Quadrant (horizontal)
2190     mask <<= (((LY + YS) / MINI_TILEY - ELY * 2) > 0) * 2;  // || (vertical)
2191
2192     // check if laser hits wall with an angle of 90°
2193     if (IS_90_ANGLE(laser.current_angle))
2194       mask += mask * (2 + IS_HORIZ_ANGLE(laser.current_angle) * 2);
2195
2196     if (mask == 1 || mask == 2 || mask == 4 || mask == 8)
2197     {
2198       int i;
2199
2200       for (i = 0; i < 4; i++)
2201       {
2202         if (mask == (1 << i) && (XS > 0) == (i % 2) && (YS > 0) == (i / 2))
2203           mask = 15 - (8 >> i);
2204         else if (ABS(XS) == 4 &&
2205                  mask == (1 << i) &&
2206                  (XS > 0) == (i % 2) &&
2207                  (YS < 0) == (i / 2))
2208           mask = 3 + (i / 2) * 9;
2209         else if (ABS(YS) == 4 &&
2210                  mask == (1 << i) &&
2211                  (XS < 0) == (i % 2) &&
2212                  (YS > 0) == (i / 2))
2213           mask = 5 + (i % 2) * 5;
2214       }
2215     }
2216
2217     laser.wall_mask = mask;
2218   }
2219   else if (IS_WALL_AMOEBA(element))
2220   {
2221     int elx = (LX - 2 * XS) / TILEX;
2222     int ely = (LY - 2 * YS) / TILEY;
2223     int element2 = Feld[elx][ely];
2224     int mask;
2225
2226     if (element2 != EL_EMPTY && !IS_WALL_AMOEBA(element2))
2227     {
2228       laser.dest_element = EL_EMPTY;
2229
2230       return TRUE;
2231     }
2232
2233     ELX = elx;
2234     ELY = ely;
2235
2236     mask = (LX - 2 * XS) / 16 - ELX * 2 + 1;
2237     mask <<= ((LY - 2 * YS) / 16 - ELY * 2) * 2;
2238
2239     if (IS_90_ANGLE(laser.current_angle))
2240       mask += mask * (2 + IS_HORIZ_ANGLE(laser.current_angle) * 2);
2241
2242     laser.dest_element = element2 | EL_WALL_AMOEBA;
2243
2244     laser.wall_mask = mask;
2245   }
2246
2247   return TRUE;
2248 }
2249
2250 static void OpenExit(int x, int y)
2251 {
2252   int delay = 6;
2253
2254   if (!MovDelay[x][y])          // next animation frame
2255     MovDelay[x][y] = 4 * delay;
2256
2257   if (MovDelay[x][y])           // wait some time before next frame
2258   {
2259     int phase;
2260
2261     MovDelay[x][y]--;
2262     phase = MovDelay[x][y] / delay;
2263
2264     if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(x, y))
2265       DrawGraphicAnimation_MM(x, y, IMG_MM_EXIT_OPENING, 3 - phase);
2266
2267     if (!MovDelay[x][y])
2268     {
2269       Feld[x][y] = EL_EXIT_OPEN;
2270       DrawField_MM(x, y);
2271     }
2272   }
2273 }
2274
2275 static void OpenSurpriseBall(int x, int y)
2276 {
2277   int delay = 2;
2278
2279   if (!MovDelay[x][y])          // next animation frame
2280     MovDelay[x][y] = 50 * delay;
2281
2282   if (MovDelay[x][y])           // wait some time before next frame
2283   {
2284     MovDelay[x][y]--;
2285
2286     if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(x, y))
2287     {
2288       Bitmap *bitmap;
2289       int graphic = el2gfx(Store[x][y]);
2290       int gx, gy;
2291       int dx = RND(26), dy = RND(26);
2292
2293       getGraphicSource(graphic, 0, &bitmap, &gx, &gy);
2294
2295       BlitBitmap(bitmap, drawto, gx + dx, gy + dy, 6, 6,
2296                  cSX + x * TILEX + dx, cSY + y * TILEY + dy);
2297
2298       MarkTileDirty(x, y);
2299     }
2300
2301     if (!MovDelay[x][y])
2302     {
2303       Feld[x][y] = Store[x][y];
2304       Store[x][y] = 0;
2305       DrawField_MM(x, y);
2306
2307       ScanLaser();
2308     }
2309   }
2310 }
2311
2312 static void MeltIce(int x, int y)
2313 {
2314   int frames = 5;
2315   int delay = 5;
2316
2317   if (!MovDelay[x][y])          // next animation frame
2318     MovDelay[x][y] = frames * delay;
2319
2320   if (MovDelay[x][y])           // wait some time before next frame
2321   {
2322     int phase;
2323     int wall_mask = Store2[x][y];
2324     int real_element = Feld[x][y] - EL_WALL_CHANGING + EL_WALL_ICE;
2325
2326     MovDelay[x][y]--;
2327     phase = frames - MovDelay[x][y] / delay - 1;
2328
2329     if (!MovDelay[x][y])
2330     {
2331       int i;
2332
2333       Feld[x][y] = real_element & (wall_mask ^ 0xFF);
2334       Store[x][y] = Store2[x][y] = 0;
2335
2336       DrawWalls_MM(x, y, Feld[x][y]);
2337
2338       if (Feld[x][y] == EL_WALL_ICE)
2339         Feld[x][y] = EL_EMPTY;
2340
2341       for (i = (laser.num_damages > 0 ? laser.num_damages - 1 : 0); i >= 0; i--)
2342         if (laser.damage[i].is_mirror)
2343           break;
2344
2345       if (i > 0)
2346         DrawLaser(laser.damage[i].edge - 1, DL_LASER_DISABLED);
2347       else
2348         DrawLaser(0, DL_LASER_DISABLED);
2349
2350       ScanLaser();
2351     }
2352     else if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(x, y))
2353     {
2354       DrawWallsAnimation_MM(x, y, real_element, phase, wall_mask);
2355
2356       laser.redraw = TRUE;
2357     }
2358   }
2359 }
2360
2361 static void GrowAmoeba(int x, int y)
2362 {
2363   int frames = 5;
2364   int delay = 1;
2365
2366   if (!MovDelay[x][y])          // next animation frame
2367     MovDelay[x][y] = frames * delay;
2368
2369   if (MovDelay[x][y])           // wait some time before next frame
2370   {
2371     int phase;
2372     int wall_mask = Store2[x][y];
2373     int real_element = Feld[x][y] - EL_WALL_CHANGING + EL_WALL_AMOEBA;
2374
2375     MovDelay[x][y]--;
2376     phase = MovDelay[x][y] / delay;
2377
2378     if (!MovDelay[x][y])
2379     {
2380       Feld[x][y] = real_element;
2381       Store[x][y] = Store2[x][y] = 0;
2382
2383       DrawWalls_MM(x, y, Feld[x][y]);
2384       DrawLaser(0, DL_LASER_ENABLED);
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   }
2391 }
2392
2393 static void Explode_MM(int x, int y, int phase, int mode)
2394 {
2395   int num_phase = 9, delay = 2;
2396   int last_phase = num_phase * delay;
2397   int half_phase = (num_phase / 2) * delay;
2398
2399   laser.redraw = TRUE;
2400
2401   if (phase == EX_PHASE_START)          // initialize 'Store[][]' field
2402   {
2403     int center_element = Feld[x][y];
2404
2405     if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
2406     {
2407       // put moving element to center field (and let it explode there)
2408       center_element = MovingOrBlocked2Element_MM(x, y);
2409       RemoveMovingField_MM(x, y);
2410
2411       Feld[x][y] = center_element;
2412     }
2413
2414     if (center_element == EL_BOMB || IS_MCDUFFIN(center_element))
2415       Store[x][y] = center_element;
2416     else
2417       Store[x][y] = EL_EMPTY;
2418
2419     Store2[x][y] = mode;
2420     Feld[x][y] = EL_EXPLODING_OPAQUE;
2421     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
2422     Frame[x][y] = 1;
2423
2424     return;
2425   }
2426
2427   Frame[x][y] = (phase < last_phase ? phase + 1 : 0);
2428
2429   if (phase == half_phase)
2430   {
2431     Feld[x][y] = EL_EXPLODING_TRANSP;
2432
2433     if (x == ELX && y == ELY)
2434       ScanLaser();
2435   }
2436
2437   if (phase == last_phase)
2438   {
2439     if (Store[x][y] == EL_BOMB)
2440     {
2441       DrawLaser(0, DL_LASER_DISABLED);
2442       InitLaser();
2443
2444       Bang_MM(laser.start_edge.x, laser.start_edge.y);
2445       Store[x][y] = EL_EMPTY;
2446
2447       game_mm.game_over = TRUE;
2448       game_mm.game_over_cause = GAME_OVER_BOMB;
2449
2450       SetTileCursorActive(FALSE);
2451
2452       laser.overloaded = FALSE;
2453     }
2454     else if (IS_MCDUFFIN(Store[x][y]))
2455     {
2456       Store[x][y] = EL_EMPTY;
2457
2458       game.restart_game_message = "Bomb killed Mc Duffin! Play it again?";
2459     }
2460
2461     Feld[x][y] = Store[x][y];
2462     Store[x][y] = Store2[x][y] = 0;
2463     MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
2464
2465     InitField(x, y, FALSE);
2466     DrawField_MM(x, y);
2467   }
2468   else if (!(phase % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
2469   {
2470     int graphic = IMG_MM_DEFAULT_EXPLODING;
2471     int graphic_phase = (phase / delay - 1);
2472     Bitmap *bitmap;
2473     int src_x, src_y;
2474
2475     if (Store2[x][y] == EX_KETTLE)
2476     {
2477       if (graphic_phase < 3)
2478       {
2479         graphic = IMG_MM_KETTLE_EXPLODING;
2480       }
2481       else if (graphic_phase < 5)
2482       {
2483         graphic_phase += 3;
2484       }
2485       else
2486       {
2487         graphic = IMG_EMPTY;
2488         graphic_phase = 0;
2489       }
2490     }
2491     else if (Store2[x][y] == EX_SHORT)
2492     {
2493       if (graphic_phase < 4)
2494       {
2495         graphic_phase += 4;
2496       }
2497       else
2498       {
2499         graphic = IMG_EMPTY;
2500         graphic_phase = 0;
2501       }
2502     }
2503
2504     getGraphicSource(graphic, graphic_phase, &bitmap, &src_x, &src_y);
2505
2506     BlitBitmap(bitmap, drawto_field, src_x, src_y, TILEX, TILEY,
2507                cFX + x * TILEX, cFY + y * TILEY);
2508
2509     MarkTileDirty(x, y);
2510   }
2511 }
2512
2513 static void Bang_MM(int x, int y)
2514 {
2515   int element = Feld[x][y];
2516   int mode = EX_NORMAL;
2517
2518 #if 0
2519   DrawLaser(0, DL_LASER_ENABLED);
2520 #endif
2521
2522   switch(element)
2523   {
2524     case EL_KETTLE:
2525       mode = EX_KETTLE;
2526       break;
2527
2528     case EL_GATE_STONE:
2529     case EL_GATE_WOOD:
2530       mode = EX_SHORT;
2531       break;
2532
2533     default:
2534       mode = EX_NORMAL;
2535       break;
2536   }
2537
2538   if (IS_PACMAN(element))
2539     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2540   else if (element == EL_BOMB || IS_MCDUFFIN(element))
2541     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2542   else if (element == EL_KEY)
2543     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2544   else
2545     PlayLevelSound_MM(x, y, element, MM_ACTION_EXPLODING);
2546
2547   Explode_MM(x, y, EX_PHASE_START, mode);
2548 }
2549
2550 void TurnRound(int x, int y)
2551 {
2552   static struct
2553   {
2554     int x, y;
2555   } move_xy[] =
2556   {
2557     { 0, 0 },
2558     {-1, 0 },
2559     {+1, 0 },
2560     { 0, 0 },
2561     { 0, -1 },
2562     { 0, 0 }, { 0, 0 }, { 0, 0 },
2563     { 0, +1 }
2564   };
2565   static struct
2566   {
2567     int left, right, back;
2568   } turn[] =
2569   {
2570     { 0,        0,              0 },
2571     { MV_DOWN,  MV_UP,          MV_RIGHT },
2572     { MV_UP,    MV_DOWN,        MV_LEFT },
2573     { 0,        0,              0 },
2574     { MV_LEFT,  MV_RIGHT,       MV_DOWN },
2575     { 0,0,0 },  { 0,0,0 },      { 0,0,0 },
2576     { MV_RIGHT, MV_LEFT,        MV_UP }
2577   };
2578
2579   int element = Feld[x][y];
2580   int old_move_dir = MovDir[x][y];
2581   int right_dir = turn[old_move_dir].right;
2582   int back_dir = turn[old_move_dir].back;
2583   int right_dx = move_xy[right_dir].x, right_dy = move_xy[right_dir].y;
2584   int right_x = x + right_dx, right_y = y + right_dy;
2585
2586   if (element == EL_PACMAN)
2587   {
2588     boolean can_turn_right = FALSE;
2589
2590     if (IN_LEV_FIELD(right_x, right_y) &&
2591         IS_EATABLE4PACMAN(Feld[right_x][right_y]))
2592       can_turn_right = TRUE;
2593
2594     if (can_turn_right)
2595       MovDir[x][y] = right_dir;
2596     else
2597       MovDir[x][y] = back_dir;
2598
2599     MovDelay[x][y] = 0;
2600   }
2601 }
2602
2603 static void StartMoving_MM(int x, int y)
2604 {
2605   int element = Feld[x][y];
2606
2607   if (Stop[x][y])
2608     return;
2609
2610   if (CAN_MOVE(element))
2611   {
2612     int newx, newy;
2613
2614     if (MovDelay[x][y])         // wait some time before next movement
2615     {
2616       MovDelay[x][y]--;
2617
2618       if (MovDelay[x][y])
2619         return;
2620     }
2621
2622     // now make next step
2623
2624     Moving2Blocked_MM(x, y, &newx, &newy);      // get next screen position
2625
2626     if (element == EL_PACMAN &&
2627         IN_LEV_FIELD(newx, newy) && IS_EATABLE4PACMAN(Feld[newx][newy]) &&
2628         !ObjHit(newx, newy, HIT_POS_CENTER))
2629     {
2630       Store[newx][newy] = Feld[newx][newy];
2631       Feld[newx][newy] = EL_EMPTY;
2632
2633       DrawField_MM(newx, newy);
2634     }
2635     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy) ||
2636              ObjHit(newx, newy, HIT_POS_CENTER))
2637     {
2638       // object was running against a wall
2639
2640       TurnRound(x, y);
2641
2642       return;
2643     }
2644
2645     InitMovingField_MM(x, y, MovDir[x][y]);
2646   }
2647
2648   if (MovDir[x][y])
2649     ContinueMoving_MM(x, y);
2650 }
2651
2652 static void ContinueMoving_MM(int x, int y)
2653 {
2654   int element = Feld[x][y];
2655   int direction = MovDir[x][y];
2656   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
2657   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
2658   int horiz_move = (dx!=0);
2659   int newx = x + dx, newy = y + dy;
2660   int step = (horiz_move ? dx : dy) * TILEX / 8;
2661
2662   MovPos[x][y] += step;
2663
2664   if (ABS(MovPos[x][y]) >= TILEX)       // object reached its destination
2665   {
2666     Feld[x][y] = EL_EMPTY;
2667     Feld[newx][newy] = element;
2668
2669     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
2670     MovDelay[newx][newy] = 0;
2671
2672     if (!CAN_MOVE(element))
2673       MovDir[newx][newy] = 0;
2674
2675     DrawField_MM(x, y);
2676     DrawField_MM(newx, newy);
2677
2678     Stop[newx][newy] = TRUE;
2679
2680     if (element == EL_PACMAN)
2681     {
2682       if (Store[newx][newy] == EL_BOMB)
2683         Bang_MM(newx, newy);
2684
2685       if (IS_WALL_AMOEBA(Store[newx][newy]) &&
2686           (LX + 2 * XS) / TILEX == newx &&
2687           (LY + 2 * YS) / TILEY == newy)
2688       {
2689         laser.num_edges--;
2690         ScanLaser();
2691       }
2692     }
2693   }
2694   else                          // still moving on
2695   {
2696     DrawField_MM(x, y);
2697   }
2698
2699   laser.redraw = TRUE;
2700 }
2701
2702 boolean ClickElement(int x, int y, int button)
2703 {
2704   static unsigned int click_delay = 0;
2705   static int click_delay_value = CLICK_DELAY;
2706   static boolean new_button = TRUE;
2707   boolean element_clicked = FALSE;
2708   int element;
2709
2710   if (button == -1)
2711   {
2712     // initialize static variables
2713     click_delay = 0;
2714     click_delay_value = CLICK_DELAY;
2715     new_button = TRUE;
2716
2717     return FALSE;
2718   }
2719
2720   // do not rotate objects hit by the laser after the game was solved
2721   if (game_mm.level_solved && Hit[x][y])
2722     return FALSE;
2723
2724   if (button == MB_RELEASED)
2725   {
2726     new_button = TRUE;
2727     click_delay_value = CLICK_DELAY;
2728
2729     // release eventually hold auto-rotating mirror
2730     RotateMirror(x, y, MB_RELEASED);
2731
2732     return FALSE;
2733   }
2734
2735   if (!FrameReached(&click_delay, click_delay_value) && !new_button)
2736     return FALSE;
2737
2738   if (button == MB_MIDDLEBUTTON)        // middle button has no function
2739     return FALSE;
2740
2741   if (!IN_LEV_FIELD(x, y))
2742     return FALSE;
2743
2744   if (Feld[x][y] == EL_EMPTY)
2745     return FALSE;
2746
2747   element = Feld[x][y];
2748
2749   if (IS_MIRROR(element) ||
2750       IS_BEAMER(element) ||
2751       IS_POLAR(element) ||
2752       IS_POLAR_CROSS(element) ||
2753       IS_DF_MIRROR(element) ||
2754       IS_DF_MIRROR_AUTO(element))
2755   {
2756     RotateMirror(x, y, button);
2757
2758     element_clicked = TRUE;
2759   }
2760   else if (IS_MCDUFFIN(element))
2761   {
2762     if (!laser.fuse_off)
2763     {
2764       DrawLaser(0, DL_LASER_DISABLED);
2765
2766       /*
2767       BackToFront();
2768       */
2769     }
2770
2771     element = get_rotated_element(element, BUTTON_ROTATION(button));
2772     laser.start_angle = get_element_angle(element);
2773
2774     InitLaser();
2775
2776     Feld[x][y] = element;
2777     DrawField_MM(x, y);
2778
2779     /*
2780     BackToFront();
2781     */
2782
2783     if (!laser.fuse_off)
2784       ScanLaser();
2785
2786     element_clicked = TRUE;
2787   }
2788   else if (element == EL_FUSE_ON && laser.fuse_off)
2789   {
2790     if (x != laser.fuse_x || y != laser.fuse_y)
2791       return FALSE;
2792
2793     laser.fuse_off = FALSE;
2794     laser.fuse_x = laser.fuse_y = -1;
2795
2796     DrawGraphic_MM(x, y, IMG_MM_FUSE_ACTIVE);
2797     ScanLaser();
2798
2799     element_clicked = TRUE;
2800   }
2801   else if (element == EL_FUSE_ON && !laser.fuse_off && new_button)
2802   {
2803     laser.fuse_off = TRUE;
2804     laser.fuse_x = x;
2805     laser.fuse_y = y;
2806     laser.overloaded = FALSE;
2807
2808     DrawLaser(0, DL_LASER_DISABLED);
2809     DrawGraphic_MM(x, y, IMG_MM_FUSE);
2810
2811     element_clicked = TRUE;
2812   }
2813   else if (element == EL_LIGHTBALL)
2814   {
2815     Bang_MM(x, y);
2816     RaiseScoreElement_MM(element);
2817     DrawLaser(0, DL_LASER_ENABLED);
2818
2819     element_clicked = TRUE;
2820   }
2821
2822   click_delay_value = (new_button ? CLICK_DELAY_FIRST : CLICK_DELAY);
2823   new_button = FALSE;
2824
2825   return element_clicked;
2826 }
2827
2828 void RotateMirror(int x, int y, int button)
2829 {
2830   if (button == MB_RELEASED)
2831   {
2832     // release eventually hold auto-rotating mirror
2833     hold_x = -1;
2834     hold_y = -1;
2835
2836     return;
2837   }
2838
2839   if (IS_MIRROR(Feld[x][y]) ||
2840       IS_POLAR_CROSS(Feld[x][y]) ||
2841       IS_POLAR(Feld[x][y]) ||
2842       IS_BEAMER(Feld[x][y]) ||
2843       IS_DF_MIRROR(Feld[x][y]) ||
2844       IS_GRID_STEEL_AUTO(Feld[x][y]) ||
2845       IS_GRID_WOOD_AUTO(Feld[x][y]))
2846   {
2847     Feld[x][y] = get_rotated_element(Feld[x][y], BUTTON_ROTATION(button));
2848   }
2849   else if (IS_DF_MIRROR_AUTO(Feld[x][y]))
2850   {
2851     if (button == MB_LEFTBUTTON)
2852     {
2853       // left mouse button only for manual adjustment, no auto-rotating;
2854       // freeze mirror for until mouse button released
2855       hold_x = x;
2856       hold_y = y;
2857     }
2858     else if (button == MB_RIGHTBUTTON && (hold_x != x || hold_y != y))
2859     {
2860       Feld[x][y] = get_rotated_element(Feld[x][y], ROTATE_RIGHT);
2861     }
2862   }
2863
2864   if (IS_GRID_STEEL_AUTO(Feld[x][y]) || IS_GRID_WOOD_AUTO(Feld[x][y]))
2865   {
2866     int edge = Hit[x][y];
2867
2868     DrawField_MM(x, y);
2869
2870     if (edge > 0)
2871     {
2872       DrawLaser(edge - 1, DL_LASER_DISABLED);
2873       ScanLaser();
2874     }
2875   }
2876   else if (ObjHit(x, y, HIT_POS_CENTER))
2877   {
2878     int edge = Hit[x][y];
2879
2880     if (edge == 0)
2881     {
2882       Error(ERR_WARN, "RotateMirror: inconsistent field Hit[][]!\n");
2883       edge = 1;
2884     }
2885
2886     DrawLaser(edge - 1, DL_LASER_DISABLED);
2887     ScanLaser();
2888   }
2889   else
2890   {
2891     int check = 1;
2892
2893     if (ObjHit(x, y, HIT_POS_EDGE | HIT_POS_BETWEEN))
2894       check = 2;
2895
2896     DrawField_MM(x, y);
2897
2898     if ((IS_BEAMER(Feld[x][y]) ||
2899          IS_POLAR(Feld[x][y]) ||
2900          IS_POLAR_CROSS(Feld[x][y])) && x == ELX && y == ELY)
2901     {
2902       check = 0;
2903
2904       if (IS_BEAMER(Feld[x][y]))
2905       {
2906 #if 0
2907         printf("TEST (%d, %d) [%d] [%d]\n",
2908                LX, LY,
2909                laser.beamer_edge, laser.beamer[1].num);
2910 #endif
2911
2912         laser.num_edges--;
2913       }
2914
2915       ScanLaser();
2916     }
2917
2918     if (check == 2)
2919       DrawLaser(0, DL_LASER_ENABLED);
2920   }
2921 }
2922
2923 static void AutoRotateMirrors(void)
2924 {
2925   int x, y;
2926
2927   if (!FrameReached(&rotate_delay, AUTO_ROTATE_DELAY))
2928     return;
2929
2930   for (x = 0; x < lev_fieldx; x++)
2931   {
2932     for (y = 0; y < lev_fieldy; y++)
2933     {
2934       int element = Feld[x][y];
2935
2936       // do not rotate objects hit by the laser after the game was solved
2937       if (game_mm.level_solved && Hit[x][y])
2938         continue;
2939
2940       if (IS_DF_MIRROR_AUTO(element) ||
2941           IS_GRID_WOOD_AUTO(element) ||
2942           IS_GRID_STEEL_AUTO(element) ||
2943           element == EL_REFRACTOR)
2944         RotateMirror(x, y, MB_RIGHTBUTTON);
2945     }
2946   }
2947 }
2948
2949 boolean ObjHit(int obx, int oby, int bits)
2950 {
2951   int i;
2952
2953   obx *= TILEX;
2954   oby *= TILEY;
2955
2956   if (bits & HIT_POS_CENTER)
2957   {
2958     if (CheckLaserPixel(cSX + obx + 15,
2959                         cSY + oby + 15))
2960       return TRUE;
2961   }
2962
2963   if (bits & HIT_POS_EDGE)
2964   {
2965     for (i = 0; i < 4; i++)
2966       if (CheckLaserPixel(cSX + obx + 31 * (i % 2),
2967                           cSY + oby + 31 * (i / 2)))
2968         return TRUE;
2969   }
2970
2971   if (bits & HIT_POS_BETWEEN)
2972   {
2973     for (i = 0; i < 4; i++)
2974       if (CheckLaserPixel(cSX + 4 + obx + 22 * (i % 2),
2975                           cSY + 4 + oby + 22 * (i / 2)))
2976         return TRUE;
2977   }
2978
2979   return FALSE;
2980 }
2981
2982 void DeletePacMan(int px, int py)
2983 {
2984   int i, j;
2985
2986   Bang_MM(px, py);
2987
2988   if (game_mm.num_pacman <= 1)
2989   {
2990     game_mm.num_pacman = 0;
2991     return;
2992   }
2993
2994   for (i = 0; i < game_mm.num_pacman; i++)
2995     if (game_mm.pacman[i].x == px && game_mm.pacman[i].y == py)
2996       break;
2997
2998   game_mm.num_pacman--;
2999
3000   for (j = i; j < game_mm.num_pacman; j++)
3001   {
3002     game_mm.pacman[j].x   = game_mm.pacman[j + 1].x;
3003     game_mm.pacman[j].y   = game_mm.pacman[j + 1].y;
3004     game_mm.pacman[j].dir = game_mm.pacman[j + 1].dir;
3005   }
3006 }
3007
3008 void ColorCycling(void)
3009 {
3010   static int CC, Cc = 0;
3011
3012   static int color, old = 0xF00, new = 0x010, mult = 1;
3013   static unsigned short red, green, blue;
3014
3015   if (color_status == STATIC_COLORS)
3016     return;
3017
3018   CC = FrameCounter;
3019
3020   if (CC < Cc || CC > Cc + 2)
3021   {
3022     Cc = CC;
3023
3024     color = old + new * mult;
3025     if (mult > 0)
3026       mult++;
3027     else
3028       mult--;
3029
3030     if (ABS(mult) == 16)
3031     {
3032       mult =- mult / 16;
3033       old = color;
3034       new = new << 4;
3035
3036       if (new > 0x100)
3037         new = 0x001;
3038     }
3039
3040     red   = 0x0e00 * ((color & 0xF00) >> 8);
3041     green = 0x0e00 * ((color & 0x0F0) >> 4);
3042     blue  = 0x0e00 * ((color & 0x00F));
3043     SetRGB(pen_magicolor[0], red, green, blue);
3044
3045     red   = 0x1111 * ((color & 0xF00) >> 8);
3046     green = 0x1111 * ((color & 0x0F0) >> 4);
3047     blue  = 0x1111 * ((color & 0x00F));
3048     SetRGB(pen_magicolor[1], red, green, blue);
3049   }
3050 }
3051
3052 static void GameActions_MM_Ext(struct MouseActionInfo action, boolean warp_mode)
3053 {
3054   int element;
3055   int x, y, i;
3056
3057   int r, d;
3058
3059   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
3060     Stop[x][y] = FALSE;
3061
3062   for (y = 0; y < lev_fieldy; y++) for (x = 0; x < lev_fieldx; x++)
3063   {
3064     element = Feld[x][y];
3065
3066     if (!IS_MOVING(x, y) && CAN_MOVE(element))
3067       StartMoving_MM(x, y);
3068     else if (IS_MOVING(x, y))
3069       ContinueMoving_MM(x, y);
3070     else if (IS_EXPLODING(element))
3071       Explode_MM(x, y, Frame[x][y], EX_NORMAL);
3072     else if (element == EL_EXIT_OPENING)
3073       OpenExit(x, y);
3074     else if (element == EL_GRAY_BALL_OPENING)
3075       OpenSurpriseBall(x, y);
3076     else if (IS_WALL_CHANGING(element) && Store[x][y] == EL_WALL_ICE)
3077       MeltIce(x, y);
3078     else if (IS_WALL_CHANGING(element) && Store[x][y] == EL_WALL_AMOEBA)
3079       GrowAmoeba(x, y);
3080   }
3081
3082   AutoRotateMirrors();
3083
3084 #if 1
3085   // !!! CHANGE THIS: REDRAW ONLY WHEN NEEDED !!!
3086
3087   // redraw after Explode_MM() ...
3088   if (laser.redraw)
3089     DrawLaser(0, DL_LASER_ENABLED);
3090   laser.redraw = FALSE;
3091 #endif
3092
3093   CT = FrameCounter;
3094
3095   if (game_mm.num_pacman && FrameReached(&pacman_delay, PACMAN_MOVE_DELAY))
3096   {
3097     MovePacMen();
3098
3099     if (laser.num_damages > MAX_LASER_LEN && !laser.fuse_off)
3100     {
3101       DrawLaser(0, DL_LASER_DISABLED);
3102       ScanLaser();
3103     }
3104   }
3105
3106   if (FrameReached(&energy_delay, ENERGY_DELAY))
3107   {
3108     if (game_mm.energy_left > 0)
3109     {
3110       game_mm.energy_left--;
3111
3112       redraw_mask |= REDRAW_DOOR_1;
3113     }
3114     else if (setup.time_limit && !game_mm.game_over)
3115     {
3116       int i;
3117
3118       for (i = 15; i >= 0; i--)
3119       {
3120 #if 0
3121         SetRGB(pen_ray, 0x0000, 0x0000, i * color_scale);
3122 #endif
3123         pen_ray = GetPixelFromRGB(window,
3124                                   native_mm_level.laser_red   * 0x11 * i,
3125                                   native_mm_level.laser_green * 0x11 * i,
3126                                   native_mm_level.laser_blue  * 0x11 * i);
3127
3128         DrawLaser(0, DL_LASER_ENABLED);
3129         BackToFront();
3130         Delay(50);
3131       }
3132
3133       StopSound_MM(SND_MM_GAME_HEALTH_CHARGING);
3134 #if 0
3135       FadeMusic();
3136 #endif
3137
3138       DrawLaser(0, DL_LASER_DISABLED);
3139       game_mm.game_over = TRUE;
3140       game_mm.game_over_cause = GAME_OVER_NO_ENERGY;
3141
3142       SetTileCursorActive(FALSE);
3143
3144       game.restart_game_message = "Out of magic energy! Play it again?";
3145
3146 #if 0
3147       if (Request("Out of magic energy! Play it again?",
3148                   REQ_ASK | REQ_STAY_CLOSED))
3149       {
3150         InitGame();
3151       }
3152       else
3153       {
3154         game_status = MAINMENU;
3155         DrawMainMenu();
3156       }
3157 #endif
3158
3159       return;
3160     }
3161   }
3162
3163   element = laser.dest_element;
3164
3165 #if 0
3166   if (element != Feld[ELX][ELY])
3167   {
3168     printf("element == %d, Feld[ELX][ELY] == %d\n",
3169            element, Feld[ELX][ELY]);
3170   }
3171 #endif
3172
3173   if (!laser.overloaded && laser.overload_value == 0 &&
3174       element != EL_BOMB &&
3175       element != EL_MINE &&
3176       element != EL_BALL_GRAY &&
3177       element != EL_BLOCK_STONE &&
3178       element != EL_BLOCK_WOOD &&
3179       element != EL_FUSE_ON &&
3180       element != EL_FUEL_FULL &&
3181       !IS_WALL_ICE(element) &&
3182       !IS_WALL_AMOEBA(element))
3183     return;
3184
3185   if (((laser.overloaded && laser.overload_value < MAX_LASER_OVERLOAD) ||
3186        (!laser.overloaded && laser.overload_value > 0)) &&
3187       FrameReached(&overload_delay, HEALTH_DELAY(laser.overloaded)))
3188   {
3189     if (laser.overloaded)
3190       laser.overload_value++;
3191     else
3192       laser.overload_value--;
3193
3194     if (game_mm.cheat_no_overload)
3195     {
3196       laser.overloaded = FALSE;
3197       laser.overload_value = 0;
3198     }
3199
3200     game_mm.laser_overload_value = laser.overload_value;
3201
3202     if (laser.overload_value < MAX_LASER_OVERLOAD - 8)
3203     {
3204       int color_up = 0xFF * laser.overload_value / MAX_LASER_OVERLOAD;
3205       int color_down = 0xFF - color_up;
3206
3207 #if 0
3208       SetRGB(pen_ray, (laser.overload_value / 6) * color_scale, 0x0000,
3209              (15 - (laser.overload_value / 6)) * color_scale);
3210 #endif
3211       pen_ray =
3212         GetPixelFromRGB(window,
3213                         (native_mm_level.laser_red  ? 0xFF : color_up),
3214                         (native_mm_level.laser_green ? color_down : 0x00),
3215                         (native_mm_level.laser_blue  ? color_down : 0x00));
3216
3217       DrawLaser(0, DL_LASER_ENABLED);
3218     }
3219
3220     if (!laser.overloaded)
3221       StopSound_MM(SND_MM_GAME_HEALTH_CHARGING);
3222     else if (setup.sound_loops)
3223       PlaySoundLoop_MM(SND_MM_GAME_HEALTH_CHARGING);
3224     else
3225       PlaySound_MM(SND_MM_GAME_HEALTH_CHARGING);
3226
3227     if (laser.overloaded)
3228     {
3229 #if 0
3230       BlitBitmap(pix[PIX_DOOR], drawto,
3231                  DOOR_GFX_PAGEX4 + XX_OVERLOAD,
3232                  DOOR_GFX_PAGEY1 + YY_OVERLOAD + OVERLOAD_YSIZE
3233                  - laser.overload_value,
3234                  OVERLOAD_XSIZE, laser.overload_value,
3235                  DX_OVERLOAD, DY_OVERLOAD + OVERLOAD_YSIZE
3236                  - laser.overload_value);
3237 #endif
3238       redraw_mask |= REDRAW_DOOR_1;
3239     }
3240     else
3241     {
3242 #if 0
3243       BlitBitmap(pix[PIX_DOOR], drawto,
3244                  DOOR_GFX_PAGEX5 + XX_OVERLOAD, DOOR_GFX_PAGEY1 + YY_OVERLOAD,
3245                  OVERLOAD_XSIZE, OVERLOAD_YSIZE - laser.overload_value,
3246                  DX_OVERLOAD, DY_OVERLOAD);
3247 #endif
3248       redraw_mask |= REDRAW_DOOR_1;
3249     }
3250
3251     if (laser.overload_value == MAX_LASER_OVERLOAD)
3252     {
3253       int i;
3254
3255       for (i = 15; i >= 0; i--)
3256       {
3257 #if 0
3258         SetRGB(pen_ray, i * color_scale, 0x0000, 0x0000);
3259 #endif
3260
3261         pen_ray = GetPixelFromRGB(window, 0x11 * i, 0x00, 0x00);
3262
3263         DrawLaser(0, DL_LASER_ENABLED);
3264         BackToFront();
3265         Delay(50);
3266       }
3267
3268       DrawLaser(0, DL_LASER_DISABLED);
3269
3270       game_mm.game_over = TRUE;
3271       game_mm.game_over_cause = GAME_OVER_OVERLOADED;
3272
3273       SetTileCursorActive(FALSE);
3274
3275       game.restart_game_message = "Magic spell hit Mc Duffin! Play it again?";
3276
3277 #if 0
3278       if (Request("Magic spell hit Mc Duffin! Play it again?",
3279                   REQ_ASK | REQ_STAY_CLOSED))
3280       {
3281         InitGame();
3282       }
3283       else
3284       {
3285         game_status = MAINMENU;
3286         DrawMainMenu();
3287       }
3288 #endif
3289
3290       return;
3291     }
3292   }
3293
3294   if (laser.fuse_off)
3295     return;
3296
3297   CT -= Ct;
3298
3299   if (element == EL_BOMB && CT > native_mm_level.time_bomb)
3300   {
3301     if (game_mm.cheat_no_explosion)
3302       return;
3303
3304 #if 0
3305     laser.num_damages--;
3306     DrawLaser(0, DL_LASER_DISABLED);
3307     laser.num_edges = 0;
3308 #endif
3309
3310     Bang_MM(ELX, ELY);
3311
3312     laser.dest_element = EL_EXPLODING_OPAQUE;
3313
3314 #if 0
3315     Bang_MM(ELX, ELY);
3316     laser.num_damages--;
3317     DrawLaser(0, DL_LASER_DISABLED);
3318
3319     laser.num_edges = 0;
3320     Bang_MM(laser.start_edge.x, laser.start_edge.y);
3321
3322     if (Request("Bomb killed Mc Duffin! Play it again?",
3323                 REQ_ASK | REQ_STAY_CLOSED))
3324     {
3325       InitGame();
3326     }
3327     else
3328     {
3329       game_status = MAINMENU;
3330       DrawMainMenu();
3331     }
3332 #endif
3333
3334     return;
3335   }
3336
3337   if (element == EL_FUSE_ON && CT > native_mm_level.time_fuse)
3338   {
3339     laser.fuse_off = TRUE;
3340     laser.fuse_x = ELX;
3341     laser.fuse_y = ELY;
3342
3343     DrawLaser(0, DL_LASER_DISABLED);
3344     DrawGraphic_MM(ELX, ELY, IMG_MM_FUSE);
3345   }
3346
3347   if (element == EL_BALL_GRAY && CT > native_mm_level.time_ball)
3348   {
3349     static int new_elements[] =
3350     {
3351       EL_MIRROR_START,
3352       EL_MIRROR_FIXED_START,
3353       EL_POLAR_START,
3354       EL_POLAR_CROSS_START,
3355       EL_PACMAN_START,
3356       EL_KETTLE,
3357       EL_BOMB,
3358       EL_PRISM
3359     };
3360     int num_new_elements = sizeof(new_elements) / sizeof(int);
3361     int new_element = new_elements[RND(num_new_elements)];
3362
3363     Store[ELX][ELY] = new_element + RND(get_num_elements(new_element));
3364     Feld[ELX][ELY] = EL_GRAY_BALL_OPENING;
3365
3366     // !!! CHECK AGAIN: Laser on Polarizer !!!
3367     ScanLaser();
3368
3369     return;
3370
3371 #if 0
3372     int graphic;
3373
3374     switch (RND(5))
3375     {
3376       case 0:
3377         element = EL_MIRROR_START + RND(16);
3378         break;
3379       case 1:
3380         {
3381           int rnd = RND(3);
3382
3383           element = (rnd == 0 ? EL_KETTLE : rnd == 1 ? EL_BOMB : EL_PRISM);
3384         }
3385         break;
3386       default:
3387         {
3388           int rnd = RND(3);
3389
3390           element = (rnd == 0 ? EL_FUSE_ON :
3391                      rnd >= 1 && rnd <= 4 ? EL_PACMAN_RIGHT + rnd - 1 :
3392                      rnd >= 5 && rnd <= 20 ? EL_POLAR_START + rnd - 5 :
3393                      rnd >= 21 && rnd <= 24 ? EL_POLAR_CROSS_START + rnd - 21 :
3394                      EL_MIRROR_FIXED_START + rnd - 25);
3395         }
3396         break;
3397     }
3398
3399     graphic = el2gfx(element);
3400
3401     for (i = 0; i < 50; i++)
3402     {
3403       int x = RND(26);
3404       int y = RND(26);
3405
3406 #if 0
3407       BlitBitmap(pix[PIX_BACK], drawto,
3408                  SX + (graphic % GFX_PER_LINE) * TILEX + x,
3409                  SY + (graphic / GFX_PER_LINE) * TILEY + y, 6, 6,
3410                  SX + ELX * TILEX + x,
3411                  SY + ELY * TILEY + y);
3412 #endif
3413       MarkTileDirty(ELX, ELY);
3414       BackToFront();
3415
3416       DrawLaser(0, DL_LASER_ENABLED);
3417
3418       Delay(50);
3419     }
3420
3421     Feld[ELX][ELY] = element;
3422     DrawField_MM(ELX, ELY);
3423
3424 #if 0
3425     printf("NEW ELEMENT: (%d, %d)\n", ELX, ELY);
3426 #endif
3427
3428     // above stuff: GRAY BALL -> PRISM !!!
3429 /*
3430     LX = ELX * TILEX + 14;
3431     LY = ELY * TILEY + 14;
3432     if (laser.current_angle == (laser.current_angle >> 1) << 1)
3433       OK = 8;
3434     else
3435       OK = 4;
3436     LX -= OK * XS;
3437     LY -= OK * YS;
3438
3439     laser.num_edges -= 2;
3440     laser.num_damages--;
3441 */
3442
3443 #if 0
3444     for (i = (laser.num_damages > 0 ? laser.num_damages - 1 : 0); i>=0; i--)
3445       if (laser.damage[i].is_mirror)
3446         break;
3447
3448     if (i > 0)
3449       DrawLaser(laser.damage[i].edge - 1, DL_LASER_DISABLED);
3450     else
3451       DrawLaser(0, DL_LASER_DISABLED);
3452 #else
3453     DrawLaser(0, DL_LASER_DISABLED);
3454 #endif
3455
3456     ScanLaser();
3457
3458     /*
3459     printf("TEST ELEMENT: %d\n", Feld[0][0]);
3460     */
3461 #endif
3462
3463     return;
3464   }
3465
3466   if (IS_WALL_ICE(element) && CT > 50)
3467   {
3468     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_SHRINKING);
3469
3470     {
3471       Feld[ELX][ELY] = Feld[ELX][ELY] - EL_WALL_ICE + EL_WALL_CHANGING;
3472       Store[ELX][ELY] = EL_WALL_ICE;
3473       Store2[ELX][ELY] = laser.wall_mask;
3474
3475       laser.dest_element = Feld[ELX][ELY];
3476
3477       return;
3478     }
3479
3480     for (i = 0; i < 5; i++)
3481     {
3482       int phase = i + 1;
3483
3484       if (i == 4)
3485       {
3486         Feld[ELX][ELY] &= (laser.wall_mask ^ 0xFF);
3487         phase = 0;
3488       }
3489
3490       DrawWallsAnimation_MM(ELX, ELY, Feld[ELX][ELY], phase, laser.wall_mask);
3491       BackToFront();
3492       Delay(100);
3493     }
3494
3495     if (Feld[ELX][ELY] == EL_WALL_ICE)
3496       Feld[ELX][ELY] = EL_EMPTY;
3497
3498 /*
3499     laser.num_edges--;
3500     LX = laser.edge[laser.num_edges].x - cSX2;
3501     LY = laser.edge[laser.num_edges].y - cSY2;
3502 */
3503
3504     for (i = (laser.num_damages > 0 ? laser.num_damages - 1 : 0); i >= 0; i--)
3505       if (laser.damage[i].is_mirror)
3506         break;
3507
3508     if (i > 0)
3509       DrawLaser(laser.damage[i].edge - 1, DL_LASER_DISABLED);
3510     else
3511       DrawLaser(0, DL_LASER_DISABLED);
3512
3513     ScanLaser();
3514
3515     return;
3516   }
3517
3518   if (IS_WALL_AMOEBA(element) && CT > 60)
3519   {
3520     int k1, k2, k3, dx, dy, de, dm;
3521     int element2 = Feld[ELX][ELY];
3522
3523     if (element2 != EL_EMPTY && !IS_WALL_AMOEBA(element))
3524       return;
3525
3526     for (i = laser.num_damages - 1; i >= 0; i--)
3527       if (laser.damage[i].is_mirror)
3528         break;
3529
3530     r = laser.num_edges;
3531     d = laser.num_damages;
3532     k1 = i;
3533
3534     if (k1 > 0)
3535     {
3536       int x, y;
3537
3538       DrawLaser(laser.damage[k1].edge - 1, DL_LASER_DISABLED);
3539
3540       laser.num_edges++;
3541       DrawLaser(0, DL_LASER_ENABLED);
3542       laser.num_edges--;
3543
3544       x = laser.damage[k1].x;
3545       y = laser.damage[k1].y;
3546
3547       DrawField_MM(x, y);
3548     }
3549
3550     for (i = 0; i < 4; i++)
3551     {
3552       if (laser.wall_mask & (1 << i))
3553       {
3554         if (CheckLaserPixel(cSX + ELX * TILEX + 14 + (i % 2) * 2,
3555                             cSY + ELY * TILEY + 31 * (i / 2)))
3556           break;
3557
3558         if (CheckLaserPixel(cSX + ELX * TILEX + 31 * (i % 2),
3559                             cSY + ELY * TILEY + 14 + (i / 2) * 2))
3560           break;
3561       }
3562     }
3563
3564     k2 = i;
3565
3566     for (i = 0; i < 4; i++)
3567     {
3568       if (laser.wall_mask & (1 << i))
3569       {
3570         if (CheckLaserPixel(cSX + ELX * TILEX + 31 * (i % 2),
3571                             cSY + ELY * TILEY + 31 * (i / 2)))
3572           break;
3573       }
3574     }
3575
3576     k3 = i;
3577
3578     if (laser.num_beamers > 0 ||
3579         k1 < 1 || k2 < 4 || k3 < 4 ||
3580         CheckLaserPixel(cSX + ELX * TILEX + 14,
3581                         cSY + ELY * TILEY + 14))
3582     {
3583       laser.num_edges = r;
3584       laser.num_damages = d;
3585
3586       DrawLaser(0, DL_LASER_DISABLED);
3587     }
3588
3589     Feld[ELX][ELY] = element | laser.wall_mask;
3590
3591     dx = ELX;
3592     dy = ELY;
3593     de = Feld[ELX][ELY];
3594     dm = laser.wall_mask;
3595
3596 #if 1
3597     {
3598       int x = ELX, y = ELY;
3599       int wall_mask = laser.wall_mask;
3600
3601       ScanLaser();
3602       DrawLaser(0, DL_LASER_ENABLED);
3603
3604       PlayLevelSound_MM(dx, dy, element, MM_ACTION_GROWING);
3605
3606       Feld[x][y] = Feld[x][y] - EL_WALL_AMOEBA + EL_WALL_CHANGING;
3607       Store[x][y] = EL_WALL_AMOEBA;
3608       Store2[x][y] = wall_mask;
3609
3610       return;
3611     }
3612 #endif
3613
3614     DrawWallsAnimation_MM(dx, dy, de, 4, dm);
3615     ScanLaser();
3616     DrawLaser(0, DL_LASER_ENABLED);
3617
3618     PlayLevelSound_MM(dx, dy, element, MM_ACTION_GROWING);
3619
3620     for (i = 4; i >= 0; i--)
3621     {
3622       DrawWallsAnimation_MM(dx, dy, de, i, dm);
3623
3624       BackToFront();
3625       Delay(20);
3626     }
3627
3628     DrawLaser(0, DL_LASER_ENABLED);
3629
3630     return;
3631   }
3632
3633   if ((element == EL_BLOCK_WOOD || element == EL_BLOCK_STONE) &&
3634       laser.stops_inside_element && CT > native_mm_level.time_block)
3635   {
3636     int x, y;
3637     int k;
3638
3639     if (ABS(XS) > ABS(YS))
3640       k = 0;
3641     else
3642       k = 1;
3643     if (XS < YS)
3644       k += 2;
3645
3646     for (i = 0; i < 4; i++)
3647     {
3648       if (i)
3649         k++;
3650       if (k > 3)
3651         k = 0;
3652
3653       x = ELX + Step[k * 4].x;
3654       y = ELY + Step[k * 4].y;
3655
3656       if (!IN_LEV_FIELD(x, y) || Feld[x][y] != EL_EMPTY)
3657         continue;
3658
3659       if (ObjHit(x, y, HIT_POS_CENTER | HIT_POS_EDGE | HIT_POS_BETWEEN))
3660         continue;
3661
3662       break;
3663     }
3664
3665     if (i > 3)
3666     {
3667       laser.overloaded = (element == EL_BLOCK_STONE);
3668
3669       return;
3670     }
3671
3672     PlayLevelSound_MM(ELX, ELY, element, MM_ACTION_PUSHING);
3673
3674     Feld[ELX][ELY] = 0;
3675     Feld[x][y] = element;
3676
3677     DrawGraphic_MM(ELX, ELY, IMG_EMPTY);
3678     DrawField_MM(x, y);
3679
3680     if (element == EL_BLOCK_STONE && Box[ELX][ELY])
3681     {
3682       DrawLaser(Box[ELX][ELY] - 1, DL_LASER_DISABLED);
3683       DrawLaser(laser.num_edges - 1, DL_LASER_ENABLED);
3684     }
3685
3686     ScanLaser();
3687
3688     return;
3689   }
3690
3691   if (element == EL_FUEL_FULL && CT > 10)
3692   {
3693     for (i = game_mm.energy_left; i <= MAX_LASER_ENERGY; i+=2)
3694     {
3695 #if 0
3696       BlitBitmap(pix[PIX_DOOR], drawto,
3697                  DOOR_GFX_PAGEX4 + XX_ENERGY,
3698                  DOOR_GFX_PAGEY1 + YY_ENERGY + ENERGY_YSIZE - i,
3699                  ENERGY_XSIZE, i, DX_ENERGY,
3700                  DY_ENERGY + ENERGY_YSIZE - i);
3701 #endif
3702
3703       redraw_mask |= REDRAW_DOOR_1;
3704       BackToFront();
3705
3706       Delay(20);
3707     }
3708
3709     game_mm.energy_left = MAX_LASER_ENERGY;
3710     Feld[ELX][ELY] = EL_FUEL_EMPTY;
3711     DrawField_MM(ELX, ELY);
3712
3713     DrawLaser(0, DL_LASER_ENABLED);
3714
3715     return;
3716   }
3717
3718   return;
3719 }
3720
3721 void GameActions_MM(struct MouseActionInfo action, boolean warp_mode)
3722 {
3723   boolean element_clicked = ClickElement(action.lx, action.ly, action.button);
3724   boolean button_released = (action.button == MB_RELEASED);
3725
3726   GameActions_MM_Ext(action, warp_mode);
3727
3728   CheckSingleStepMode_MM(element_clicked, button_released);
3729 }
3730
3731 void MovePacMen(void)
3732 {
3733   int mx, my, ox, oy, nx, ny;
3734   int element;
3735   int l;
3736
3737   if (++pacman_nr >= game_mm.num_pacman)
3738     pacman_nr = 0;
3739
3740   game_mm.pacman[pacman_nr].dir--;
3741
3742   for (l = 1; l < 5; l++)
3743   {
3744     game_mm.pacman[pacman_nr].dir++;
3745
3746     if (game_mm.pacman[pacman_nr].dir > 4)
3747       game_mm.pacman[pacman_nr].dir = 1;
3748
3749     if (game_mm.pacman[pacman_nr].dir % 2)
3750     {
3751       mx = 0;
3752       my = game_mm.pacman[pacman_nr].dir - 2;
3753     }
3754     else
3755     {
3756       my = 0;
3757       mx = 3 - game_mm.pacman[pacman_nr].dir;
3758     }
3759
3760     ox = game_mm.pacman[pacman_nr].x;
3761     oy = game_mm.pacman[pacman_nr].y;
3762     nx = ox + mx;
3763     ny = oy + my;
3764     element = Feld[nx][ny];
3765
3766     if (nx < 0 || nx > 15 || ny < 0 || ny > 11)
3767       continue;
3768
3769     if (!IS_EATABLE4PACMAN(element))
3770       continue;
3771
3772     if (ObjHit(nx, ny, HIT_POS_CENTER))
3773       continue;
3774
3775     Feld[ox][oy] = EL_EMPTY;
3776     Feld[nx][ny] =
3777       EL_PACMAN_RIGHT - 1 +
3778       (game_mm.pacman[pacman_nr].dir - 1 +
3779        (game_mm.pacman[pacman_nr].dir % 2) * 2);
3780
3781     game_mm.pacman[pacman_nr].x = nx;
3782     game_mm.pacman[pacman_nr].y = ny;
3783
3784     DrawGraphic_MM(ox, oy, IMG_EMPTY);
3785
3786     if (element != EL_EMPTY)
3787     {
3788       int graphic = el2gfx(Feld[nx][ny]);
3789       Bitmap *bitmap;
3790       int src_x, src_y;
3791       int i;
3792
3793       getGraphicSource(graphic, 0, &bitmap, &src_x, &src_y);
3794
3795       CT = FrameCounter;
3796       ox = cSX + ox * TILEX;
3797       oy = cSY + oy * TILEY;
3798
3799       for (i = 1; i < 33; i += 2)
3800         BlitBitmap(bitmap, window,
3801                    src_x, src_y, TILEX, TILEY,
3802                    ox + i * mx, oy + i * my);
3803       Ct = Ct + FrameCounter - CT;
3804     }
3805
3806     DrawField_MM(nx, ny);
3807     BackToFront();
3808
3809     if (!laser.fuse_off)
3810     {
3811       DrawLaser(0, DL_LASER_ENABLED);
3812
3813       if (ObjHit(nx, ny, HIT_POS_BETWEEN))
3814       {
3815         AddDamagedField(nx, ny);
3816
3817         laser.damage[laser.num_damages - 1].edge = 0;
3818       }
3819     }
3820
3821     if (element == EL_BOMB)
3822       DeletePacMan(nx, ny);
3823
3824     if (IS_WALL_AMOEBA(element) &&
3825         (LX + 2 * XS) / TILEX == nx &&
3826         (LY + 2 * YS) / TILEY == ny)
3827     {
3828       laser.num_edges--;
3829       ScanLaser();
3830     }
3831
3832     break;
3833   }
3834 }
3835
3836 void GameWon_MM(void)
3837 {
3838   int hi_pos;
3839   boolean raise_level = FALSE;
3840
3841 #if 0
3842   if (local_player->MovPos)
3843     return;
3844
3845   local_player->LevelSolved = FALSE;
3846 #endif
3847
3848   if (game_mm.energy_left)
3849   {
3850     if (setup.sound_loops)
3851       PlaySoundExt(SND_SIRR, SOUND_MAX_VOLUME, SOUND_MAX_RIGHT,
3852                    SND_CTRL_PLAY_LOOP);
3853
3854     while (game_mm.energy_left > 0)
3855     {
3856       if (!setup.sound_loops)
3857         PlaySoundStereo(SND_SIRR, SOUND_MAX_RIGHT);
3858
3859       /*
3860       if (game_mm.energy_left > 0 && !(game_mm.energy_left % 10))
3861         RaiseScore_MM(native_mm_level.score[SC_ZEITBONUS]);
3862       */
3863
3864       RaiseScore_MM(5);
3865
3866       game_mm.energy_left--;
3867       if (game_mm.energy_left >= 0)
3868       {
3869 #if 0
3870         BlitBitmap(pix[PIX_DOOR], drawto,
3871                    DOOR_GFX_PAGEX5 + XX_ENERGY, DOOR_GFX_PAGEY1 + YY_ENERGY,
3872                    ENERGY_XSIZE, ENERGY_YSIZE - game_mm.energy_left,
3873                    DX_ENERGY, DY_ENERGY);
3874 #endif
3875         redraw_mask |= REDRAW_DOOR_1;
3876       }
3877
3878       BackToFront();
3879       Delay(10);
3880     }