minor whitespace change
[rocksndiamonds.git] / src / game_mm / mm_tools.c
1 /***********************************************************
2 * Mirror Magic -- McDuffin's Revenge                       *
3 *----------------------------------------------------------*
4 * (c) 1994-2001 Artsoft Entertainment                      *
5 *               Holger Schemel                             *
6 *               Detmolder Strasse 189                      *
7 *               33604 Bielefeld                            *
8 *               Germany                                    *
9 *               e-mail: info@artsoft.org                   *
10 *----------------------------------------------------------*
11 * tools.c                                                  *
12 ***********************************************************/
13
14 #include "main_mm.h"
15
16 #include "mm_main.h"
17 #include "mm_tools.h"
18
19
20 void ClearWindow()
21 {
22   ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
23
24   SetDrawtoField(DRAW_BACKBUFFER);
25
26   redraw_mask |= REDRAW_FIELD;
27 }
28
29 void DrawGraphicAnimation_MM(int x, int y, int graphic, int frame)
30 {
31   Bitmap *bitmap;
32   int src_x, src_y;
33
34   getGraphicSource(graphic, frame, &bitmap, &src_x, &src_y);
35
36   BlitBitmap(bitmap, drawto_field, src_x, src_y, TILEX, TILEY,
37              FX + x * TILEX, FY + y * TILEY);
38 }
39
40 void DrawGraphic_MM(int x, int y, int graphic)
41 {
42 #if DEBUG
43   if (!IN_SCR_FIELD(x,y))
44   {
45     printf("DrawGraphic_MM(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
46     printf("DrawGraphic_MM(): This should never happen!\n");
47     return;
48   }
49 #endif
50
51   DrawGraphicExt_MM(drawto_field, FX + x*TILEX, FY + y*TILEY, graphic);
52
53   MarkTileDirty(x, y);
54 }
55
56 void DrawGraphicExt_MM(DrawBuffer *d, int x, int y, int graphic)
57 {
58   Bitmap *bitmap;
59   int src_x, src_y;
60
61   getGraphicSource(graphic, 0, &bitmap, &src_x, &src_y);
62
63   BlitBitmap(bitmap, d, src_x, src_y, TILEX, TILEY, x, y);
64 }
65
66 void DrawGraphicThruMask_MM(int x, int y, int graphic)
67 {
68 #if DEBUG
69   if (!IN_SCR_FIELD(x,y))
70   {
71     printf("DrawGraphicThruMask_MM(): x = %d,y = %d, graphic = %d\n",x,y,graphic);
72     printf("DrawGraphicThruMask_MM(): This should never happen!\n");
73     return;
74   }
75 #endif
76
77   DrawGraphicThruMaskExt_MM(drawto_field, FX + x * TILEX, FY + y * TILEY,
78                             graphic);
79
80   MarkTileDirty(x,y);
81 }
82
83 void DrawGraphicThruMaskExt_MM(DrawBuffer *d, int dest_x, int dest_y,
84                                int graphic)
85 {
86   int src_x, src_y;
87   Bitmap *src_bitmap;
88
89   if (graphic == IMG_EMPTY)
90     return;
91
92   getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
93
94   BlitBitmapMasked(src_bitmap, d, src_x, src_y, TILEX, TILEY, dest_x, dest_y);
95 }
96
97 void DrawMiniGraphic_MM(int x, int y, int graphic)
98 {
99   DrawMiniGraphicExt_MM(drawto, SX + x * MINI_TILEX, SY + y * MINI_TILEY,
100                         graphic);
101
102   MarkTileDirty(x / 2, y / 2);
103 }
104
105 void getMicroGraphicSource(int graphic, Bitmap **bitmap, int *x, int *y)
106 {
107   getSizedGraphicSource(graphic, 0, TILESIZE / 4, bitmap, x, y);
108 }
109
110 void DrawMiniGraphicExt_MM(DrawBuffer *d, int x, int y, int graphic)
111 {
112   Bitmap *bitmap;
113   int src_x, src_y;
114
115   getMiniGraphicSource(graphic, &bitmap, &src_x, &src_y);
116
117   BlitBitmap(bitmap, d, src_x, src_y, MINI_TILEX, MINI_TILEY, x, y);
118 }
119
120 void DrawGraphicShifted_MM(int x,int y, int dx,int dy, int graphic,
121                         int cut_mode, int mask_mode)
122 {
123   int width = TILEX, height = TILEY;
124   int cx = 0, cy = 0;
125   int src_x, src_y, dest_x, dest_y;
126   Bitmap *src_bitmap;
127
128   if (graphic < 0)
129   {
130     DrawGraphic_MM(x, y, graphic);
131
132     return;
133   }
134
135   if (dx || dy)                 /* Verschiebung der Grafik? */
136   {
137     if (x < BX1)                /* Element kommt von links ins Bild */
138     {
139       x = BX1;
140       width = dx;
141       cx = TILEX - dx;
142       dx = 0;
143     }
144     else if (x > BX2)           /* Element kommt von rechts ins Bild */
145     {
146       x = BX2;
147       width = -dx;
148       dx = TILEX + dx;
149     }
150     else if (x==BX1 && dx < 0)  /* Element verläßt links das Bild */
151     {
152       width += dx;
153       cx = -dx;
154       dx = 0;
155     }
156     else if (x==BX2 && dx > 0)  /* Element verläßt rechts das Bild */
157       width -= dx;
158     else if (dx)                /* allg. Bewegung in x-Richtung */
159       MarkTileDirty(x + SIGN(dx), y);
160
161     if (y < BY1)                /* Element kommt von oben ins Bild */
162     {
163       if (cut_mode==CUT_BELOW)  /* Element oberhalb des Bildes */
164         return;
165
166       y = BY1;
167       height = dy;
168       cy = TILEY - dy;
169       dy = 0;
170     }
171     else if (y > BY2)           /* Element kommt von unten ins Bild */
172     {
173       y = BY2;
174       height = -dy;
175       dy = TILEY + dy;
176     }
177     else if (y==BY1 && dy < 0)  /* Element verläßt oben das Bild */
178     {
179       height += dy;
180       cy = -dy;
181       dy = 0;
182     }
183     else if (dy > 0 && cut_mode == CUT_ABOVE)
184     {
185       if (y == BY2)             /* Element unterhalb des Bildes */
186         return;
187
188       height = dy;
189       cy = TILEY - dy;
190       dy = TILEY;
191       MarkTileDirty(x, y + 1);
192     }                           /* Element verläßt unten das Bild */
193     else if (dy > 0 && (y == BY2 || cut_mode == CUT_BELOW))
194     {
195       height -= dy;
196     }
197     else if (dy)                /* allg. Bewegung in y-Richtung */
198     {
199       MarkTileDirty(x, y + SIGN(dy));
200     }
201   }
202
203   getGraphicSource(graphic, 0, &src_bitmap, &src_x, &src_y);
204
205   src_x += cx;
206   src_y += cy;
207
208   dest_x = FX + x * TILEX + dx;
209   dest_y = FY + y * TILEY + dy;
210
211 #if DEBUG
212   if (!IN_SCR_FIELD(x,y))
213   {
214     printf("DrawGraphicShifted_MM(): x = %d, y = %d, graphic = %d\n",x,y,graphic);
215     printf("DrawGraphicShifted_MM(): This should never happen!\n");
216     return;
217   }
218 #endif
219
220   if (mask_mode == USE_MASKING)
221     BlitBitmapMasked(src_bitmap, drawto_field,
222                      src_x, src_y, TILEX, TILEY, dest_x, dest_y);
223   else
224     BlitBitmap(src_bitmap, drawto_field,
225                src_x, src_y, width, height, dest_x, dest_y);
226
227   MarkTileDirty(x,y);
228 }
229
230 void DrawGraphicShiftedThruMask_MM(int x,int y, int dx,int dy, int graphic,
231                                 int cut_mode)
232 {
233   DrawGraphicShifted_MM(x, y, dx, dy, graphic, cut_mode, USE_MASKING);
234 }
235
236 void DrawScreenElementExt_MM(int x, int y, int dx, int dy, int element,
237                           int cut_mode, int mask_mode)
238 {
239   int ux = LEVELX(x), uy = LEVELY(y);
240   int graphic = el2gfx(element);
241   int phase8 = ABS(MovPos[ux][uy]) / (TILEX / 8);
242   int phase2  = phase8 / 4;
243   int dir = MovDir[ux][uy];
244
245   if (element == EL_PACMAN)
246   {
247     graphic = (phase2 ? IMG_MM_PACMAN_RIGHT : IMG_MM_PACMAN_EATING_RIGHT);
248
249     if (dir == MV_UP)
250       graphic += 1;
251     else if (dir == MV_LEFT)
252       graphic += 2;
253     else if (dir == MV_DOWN)
254       graphic += 3;
255   }
256
257   if (dx || dy)
258     DrawGraphicShifted_MM(x, y, dx, dy, graphic, cut_mode, mask_mode);
259   else if (mask_mode == USE_MASKING)
260     DrawGraphicThruMask_MM(x, y, graphic);
261   else
262     DrawGraphic_MM(x, y, graphic);
263 }
264
265 void DrawLevelElementExt_MM(int x, int y, int dx, int dy, int element,
266                          int cut_mode, int mask_mode)
267 {
268   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
269     DrawScreenElementExt_MM(SCREENX(x), SCREENY(y), dx, dy, element,
270                          cut_mode, mask_mode);
271 }
272
273 void DrawScreenElementShifted_MM(int x, int y, int dx, int dy, int element,
274                               int cut_mode)
275 {
276   DrawScreenElementExt_MM(x, y, dx, dy, element, cut_mode, NO_MASKING);
277 }
278
279 void DrawLevelElementShifted_MM(int x, int y, int dx, int dy, int element,
280                              int cut_mode)
281 {
282   DrawLevelElementExt_MM(x, y, dx, dy, element, cut_mode, NO_MASKING);
283 }
284
285 void DrawScreenElementThruMask_MM(int x, int y, int element)
286 {
287   DrawScreenElementExt_MM(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
288 }
289
290 void DrawLevelElementThruMask_MM(int x, int y, int element)
291 {
292   DrawLevelElementExt_MM(x, y, 0, 0, element, NO_CUTTING, USE_MASKING);
293 }
294
295 void DrawLevelFieldThruMask_MM(int x, int y)
296 {
297   DrawLevelElementExt_MM(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
298 }
299
300 void DrawScreenElement_MM(int x, int y, int element)
301 {
302   DrawScreenElementExt_MM(x, y, 0, 0, element, NO_CUTTING, NO_MASKING);
303 }
304
305 void DrawLevelElement_MM(int x, int y, int element)
306 {
307   if (IN_LEV_FIELD(x, y) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
308     DrawScreenElement_MM(SCREENX(x), SCREENY(y), element);
309 }
310
311 void DrawScreenField_MM(int x, int y)
312 {
313   int element = Feld[x][y];
314
315   if (!IN_LEV_FIELD(x, y))
316     return;
317
318   if (IS_MOVING(x, y))
319   {
320     int horiz_move = (MovDir[x][y] == MV_LEFT || MovDir[x][y] == MV_RIGHT);
321
322     DrawScreenElement_MM(x, y, EL_EMPTY);
323
324     if (horiz_move)
325       DrawScreenElementShifted_MM(x, y, MovPos[x][y], 0, element, NO_CUTTING);
326     else
327       DrawScreenElementShifted_MM(x, y, 0, MovPos[x][y], element, NO_CUTTING);
328   }
329   else if (IS_BLOCKED(x, y))
330   {
331     int oldx, oldy;
332     int sx, sy;
333     int horiz_move;
334
335     Blocked2Moving(x, y, &oldx, &oldy);
336
337     sx = SCREENX(oldx);
338     sy = SCREENY(oldy);
339     horiz_move = (MovDir[oldx][oldy] == MV_LEFT ||
340                   MovDir[oldx][oldy] == MV_RIGHT);
341
342     DrawScreenElement_MM(x, y, EL_EMPTY);
343
344     element = Feld[oldx][oldy];
345
346     if (horiz_move)
347       DrawScreenElementShifted_MM(sx, sy, MovPos[oldx][oldy], 0, element,
348                                   NO_CUTTING);
349     else
350       DrawScreenElementShifted_MM(sx, sy, 0, MovPos[oldx][oldy], element,
351                                   NO_CUTTING);
352   }
353   else if (IS_DRAWABLE(element))
354   {
355     DrawScreenElement_MM(x, y, element);
356   }
357   else
358   {
359     DrawScreenElement_MM(x, y, EL_EMPTY);
360   }
361 }
362
363 void DrawLevelField_MM(int x, int y)
364 {
365   DrawScreenField_MM(x, y);
366 }
367
368 void DrawMiniElement_MM(int x, int y, int element)
369 {
370   int graphic;
371
372   if (!element)
373   {
374     DrawMiniGraphic_MM(x, y, IMG_EMPTY);
375
376     return;
377   }
378
379   graphic = el2gfx(element);
380
381   DrawMiniGraphic_MM(x, y, graphic);
382 }
383
384 void DrawMiniElementOrWall_MM(int sx, int sy, int scroll_x, int scroll_y)
385 {
386   int x = sx + scroll_x, y = sy + scroll_y;
387
388   if (x < -1 || x > lev_fieldx || y < -1 || y > lev_fieldy)
389     DrawMiniElement_MM(sx, sy, EL_EMPTY);
390   else if (x > -1 && x < lev_fieldx && y > -1 && y < lev_fieldy)
391     DrawMiniElement_MM(sx, sy, Feld[x][y]);
392 }
393
394 void DrawField_MM(int x, int y)
395 {
396   int element = Feld[x][y];
397
398   DrawElement_MM(x, y, element);
399 }
400
401 void DrawLevel_MM()
402 {
403   int x,y;
404
405   ClearWindow();
406
407   for (x = 0; x < lev_fieldx; x++)
408     for (y = 0; y < lev_fieldy; y++)
409       DrawField_MM(x, y);
410
411   redraw_mask |= REDRAW_FIELD;
412 }
413
414 void DrawWallsExt_MM(int x, int y, int element, int draw_mask)
415 {
416   Bitmap *bitmap;
417   int graphic = el2gfx(WALL_BASE(element));
418   int gx, gy;
419   int i;
420
421   getMiniGraphicSource(graphic, &bitmap, &gx, &gy);
422
423   DrawGraphic_MM(x, y, IMG_EMPTY);
424
425   /*
426   if (IS_WALL_WOOD(element) || IS_WALL_AMOEBA(element) ||
427       IS_DF_WALL_WOOD(element))
428     gx += MINI_TILEX;
429   if (IS_WALL_ICE(element) || IS_WALL_AMOEBA(element))
430     gy += MINI_TILEY;
431   */
432
433   for (i = 0; i < 4; i++)
434   {
435     int dest_x = SX + x * TILEX + MINI_TILEX * (i % 2);
436     int dest_y = SY + y * TILEY + MINI_TILEY * (i / 2);
437
438     if (!((1 << i) & draw_mask))
439       continue;
440
441     if (element & (1 << i))
442       BlitBitmap(bitmap, drawto, gx, gy, MINI_TILEX, MINI_TILEY,
443                  dest_x, dest_y);
444     else
445       ClearRectangle(drawto, dest_x, dest_y, MINI_TILEX, MINI_TILEY);
446   }
447
448   MarkTileDirty(x, y);
449 }
450
451 void DrawWalls_MM(int x, int y, int element)
452 {
453   DrawWallsExt_MM(x, y, element, HIT_MASK_ALL);
454 }
455
456 void DrawWallsAnimation_MM(int x, int y, int element, int phase, int bit_mask)
457 {
458   int i;
459
460   if (phase == 0)
461   {
462     DrawWalls_MM(x, y, element);
463
464     return;
465   }
466
467   for (i = 0; i < 4; i++)
468   {
469     if (element & (1 << i))
470     {
471       int graphic;
472       int frame;
473       Bitmap *bitmap;
474       int src_x, src_y;
475       int dst_x = SX + x * TILEX + (i % 2) * MINI_TILEX;
476       int dst_y = SY + y * TILEY + (i / 2) * MINI_TILEY;
477
478       if (bit_mask & (1 << i))
479       {
480         graphic = (IS_WALL_AMOEBA(element) ?
481                    IMG_MM_AMOEBA_WALL_GROWING :
482                    IMG_MM_ICE_WALL_SHRINKING);
483         frame = phase;
484       }
485       else
486       {
487         graphic = (IS_WALL_AMOEBA(element) ?
488                    IMG_MM_AMOEBA_WALL :
489                    IMG_MM_ICE_WALL);
490         frame = 0;
491       }
492
493       getSizedGraphicSource(graphic, frame, MINI_TILESIZE, &bitmap,
494                             &src_x, &src_y);
495
496       BlitBitmap(bitmap, drawto, src_x, src_y, MINI_TILEX, MINI_TILEY,
497                  dst_x, dst_y);
498     }
499   }
500
501   MarkTileDirty(x, y);
502 }
503
504 void DrawElement_MM(int x, int y, int element)
505 {
506   if (element == EL_EMPTY)
507     DrawGraphic_MM(x, y, IMG_EMPTY);
508   else if (IS_WALL(element))
509     DrawWalls_MM(x, y, element);
510 #if 0
511   else if (IS_WALL_CHANGING(element) && IS_WALL_CHANGING(Feld[x][y]))
512   {
513     int wall_element = Feld[x][y] - EL_WALL_CHANGING + Store[x][y];
514
515     DrawWalls_MM(x, y, wall_element);
516   }
517 #endif
518   else if (element == EL_PACMAN)
519     DrawLevelField_MM(x, y);
520   else
521     DrawGraphic_MM(x, y, el2gfx(element));
522 }
523
524 void DrawMicroWalls_MM(int x, int y, int element)
525 {
526   Bitmap *bitmap;
527   int graphic = el2gfx(WALL_BASE(element));
528   int gx, gy;
529   int i;
530
531   getMicroGraphicSource(graphic, &bitmap, &gx, &gy);
532
533   for (i = 0; i < 4; i++)
534   {
535     int xpos = MICROLEV_XPOS + x * MICRO_TILEX + MICRO_WALLX * (i % 2);
536     int ypos = MICROLEV_YPOS + y * MICRO_TILEY + MICRO_WALLY * (i / 2);
537
538     if (element & (1 << i))
539       BlitBitmap(bitmap, drawto, gx, gy, MICRO_WALLX, MICRO_WALLY, xpos, ypos);
540     else
541       ClearRectangle(drawto, xpos, ypos, MICRO_WALLX, MICRO_WALLY);
542   }
543 }
544
545 void DrawMicroElement_MM(int x, int y, int element)
546 {
547   Bitmap *bitmap;
548   int graphic = el2gfx(element);
549   int gx, gy;
550
551   if (element == EL_EMPTY)
552     return;
553
554   if (IS_WALL(element))
555   {
556     DrawMicroWalls_MM(x, y, element);
557
558     return;
559   }
560
561   getMicroGraphicSource(graphic, &bitmap, &gx, &gy);
562
563   BlitBitmap(bitmap, drawto, gx, gy, MICRO_TILEX, MICRO_TILEY,
564              MICROLEV_XPOS + x * MICRO_TILEX, MICROLEV_YPOS + y * MICRO_TILEY);
565 }
566
567 void DrawMicroLevelExt_MM(int xpos, int ypos)
568 {
569   int x, y;
570
571   ClearRectangle(drawto, xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE);
572
573   for (x = 0; x < STD_LEV_FIELDX; x++)
574     for (y = 0; y < STD_LEV_FIELDY; y++)
575       DrawMicroElement_MM(x, y, Ur[x][y]);
576
577   redraw_mask |= REDRAW_FIELD;
578 }
579
580 void DrawMiniLevel_MM(int size_x, int size_y, int scroll_x, int scroll_y)
581 {
582   int x, y;
583
584   for(x = 0; x < size_x; x++)
585     for(y = 0; y < size_y; y++)
586       DrawMiniElementOrWall_MM(x, y, scroll_x, scroll_y);
587
588   redraw_mask |= REDRAW_FIELD;
589 }
590
591 int REQ_in_range(int x, int y)
592 {
593   if (y > DY + 249 && y < DY + 278)
594   {
595     if (x > DX + 1 && x < DX + 48)
596       return 1;
597     else if (x > DX + 51 && x < DX + 98)
598       return 2;
599   }
600
601   return 0;
602 }
603
604 Pixel ReadPixel(DrawBuffer *bitmap, int x, int y)
605 {
606   return GetPixel(bitmap, x, y);
607 }
608
609 void SetRGB(unsigned int pixel,
610             unsigned short red, unsigned short green, unsigned short blue)
611 {
612 }
613
614 int get_base_element(int element)
615 {
616   if (IS_MIRROR(element))
617     return EL_MIRROR_START;
618   else if (IS_MIRROR_FIXED(element))
619     return EL_MIRROR_FIXED_START;
620   else if (IS_POLAR(element))
621     return EL_POLAR_START;
622   else if (IS_POLAR_CROSS(element))
623     return EL_POLAR_CROSS_START;
624   else if (IS_BEAMER(element))
625     return EL_BEAMER_RED_START + BEAMER_NR(element) * 16;
626   else if (IS_FIBRE_OPTIC(element))
627     return EL_FIBRE_OPTIC_START + FIBRE_OPTIC_NR(element) * 2;
628   else if (IS_MCDUFFIN(element))
629     return EL_MCDUFFIN_START;
630   else if (IS_LASER(element))
631     return EL_LASER_START;
632   else if (IS_RECEIVER(element))
633     return EL_RECEIVER_START;
634   else if (IS_DF_MIRROR(element))
635     return EL_DF_MIRROR_START;
636   else if (IS_DF_MIRROR_AUTO(element))
637     return EL_DF_MIRROR_AUTO_START;
638   else if (IS_PACMAN(element))
639     return EL_PACMAN_START;
640   else if (IS_GRID_STEEL(element))
641     return EL_GRID_STEEL_START;
642   else if (IS_GRID_WOOD(element))
643     return EL_GRID_WOOD_START;
644   else if (IS_GRID_STEEL_FIXED(element))
645     return EL_GRID_STEEL_FIXED_START;
646   else if (IS_GRID_WOOD_FIXED(element))
647     return EL_GRID_WOOD_FIXED_START;
648   else if (IS_GRID_STEEL_AUTO(element))
649     return EL_GRID_STEEL_AUTO_START;
650   else if (IS_GRID_WOOD_AUTO(element))
651     return EL_GRID_WOOD_AUTO_START;
652   else if (IS_WALL_STEEL(element))
653     return EL_WALL_STEEL_START;
654   else if (IS_WALL_WOOD(element))
655     return EL_WALL_WOOD_START;
656   else if (IS_WALL_ICE(element))
657     return EL_WALL_ICE_START;
658   else if (IS_WALL_AMOEBA(element))
659     return EL_WALL_AMOEBA_START;
660   else if (IS_DF_WALL_STEEL(element))
661     return EL_DF_WALL_STEEL_START;
662   else if (IS_DF_WALL_WOOD(element))
663     return EL_DF_WALL_WOOD_START;
664   else if (IS_CHAR(element))
665     return EL_CHAR_START;
666   else
667     return element;
668 }
669
670 int get_element_phase(int element)
671 {
672   return element - get_base_element(element);
673 }
674
675 int get_num_elements(int element)
676 {
677   if (IS_MIRROR(element) ||
678       IS_POLAR(element) ||
679       IS_BEAMER(element) ||
680       IS_DF_MIRROR(element) ||
681       IS_DF_MIRROR_AUTO(element))
682     return 16;
683   else if (IS_GRID_STEEL_FIXED(element) ||
684            IS_GRID_WOOD_FIXED(element) ||
685            IS_GRID_STEEL_AUTO(element) ||
686            IS_GRID_WOOD_AUTO(element))
687     return 8;
688   else if (IS_MIRROR_FIXED(element) ||
689            IS_POLAR_CROSS(element) ||
690            IS_MCDUFFIN(element) ||
691            IS_LASER(element) ||
692            IS_RECEIVER(element) ||
693            IS_PACMAN(element) ||
694            IS_GRID_STEEL(element) ||
695            IS_GRID_WOOD(element))
696     return 4;
697   else
698     return 1;
699 }
700
701 int get_rotated_element(int element, int step)
702 {
703   int base_element = get_base_element(element);
704   int num_elements = get_num_elements(element);
705   int element_phase = element - base_element;
706
707   return base_element + (element_phase + step + num_elements) % num_elements;
708 }
709
710 static int map_element(int element)
711 {
712   switch (element)
713   {
714     case EL_WALL_STEEL:         return EL_STEEL_WALL;
715     case EL_WALL_WOOD:          return EL_WOODEN_WALL;
716     case EL_WALL_ICE:           return EL_ICE_WALL;
717     case EL_WALL_AMOEBA:        return EL_AMOEBA_WALL;
718     case EL_DF_WALL_STEEL:      return EL_DF_STEEL_WALL;
719     case EL_DF_WALL_WOOD:       return EL_DF_WOODEN_WALL;
720
721     default:                    return element;
722   }
723 }
724
725 int el2gfx(int element)
726 {
727   element = map_element(element);
728
729   switch (element)
730   {
731     case EL_LIGHTBALL:
732       return IMG_MM_LIGHTBALL_RED + RND(3);
733
734     default:
735       return el2img_mm(element);
736   }
737 }
738
739 void RedrawPlayfield_MM()
740 {
741   DrawLevel_MM();
742 }
743
744 void BlitScreenToBitmap_MM(Bitmap *target_bitmap)
745 {
746   BlitBitmap(drawto_field, target_bitmap,
747              REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
748 }