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 if (element == EL_FUSE_ON &&
 521            laser.fuse_off &&
 522            laser.fuse_x == x &&
 523            laser.fuse_y == y)
 524     DrawGraphic_MM(x, y, IMG_MM_FUSE);
 525   else
 526     DrawGraphic_MM(x, y, el2gfx(element));
 527 }
 528
 529 void DrawMicroWalls_MM(int x, int y, int element)
 530 {
 531   Bitmap *bitmap;
 532   int graphic = el2gfx(WALL_BASE(element));
 533   int gx, gy;
 534   int i;
 535
 536   getMicroGraphicSource(graphic, &bitmap, &gx, &gy);
 537
 538   for (i = 0; i < 4; i++)
 539   {
 540     int xpos = MICROLEV_XPOS + x * MICRO_TILEX + MICRO_WALLX * (i % 2);
 541     int ypos = MICROLEV_YPOS + y * MICRO_TILEY + MICRO_WALLY * (i / 2);
 542
 543     if (element & (1 << i))
 544       BlitBitmap(bitmap, drawto, gx, gy, MICRO_WALLX, MICRO_WALLY, xpos, ypos);
 545     else
 546       ClearRectangle(drawto, xpos, ypos, MICRO_WALLX, MICRO_WALLY);
 547   }
 548 }
 549
 550 void DrawMicroElement_MM(int x, int y, int element)
 551 {
 552   Bitmap *bitmap;
 553   int graphic = el2gfx(element);
 554   int gx, gy;
 555
 556   if (element == EL_EMPTY)
 557     return;
 558
 559   if (IS_WALL(element))
 560   {
 561     DrawMicroWalls_MM(x, y, element);
 562
 563     return;
 564   }
 565
 566   getMicroGraphicSource(graphic, &bitmap, &gx, &gy);
 567
 568   BlitBitmap(bitmap, drawto, gx, gy, MICRO_TILEX, MICRO_TILEY,
 569              MICROLEV_XPOS + x * MICRO_TILEX, MICROLEV_YPOS + y * MICRO_TILEY);
 570 }
 571
 572 void DrawMicroLevelExt_MM(int xpos, int ypos)
 573 {
 574   int x, y;
 575
 576   ClearRectangle(drawto, xpos, ypos, MICROLEV_XSIZE, MICROLEV_YSIZE);
 577
 578   for (x = 0; x < STD_LEV_FIELDX; x++)
 579     for (y = 0; y < STD_LEV_FIELDY; y++)
 580       DrawMicroElement_MM(x, y, Ur[x][y]);
 581
 582   redraw_mask |= REDRAW_FIELD;
 583 }
 584
 585 void DrawMiniLevel_MM(int size_x, int size_y, int scroll_x, int scroll_y)
 586 {
 587   int x, y;
 588
 589   for(x = 0; x < size_x; x++)
 590     for(y = 0; y < size_y; y++)
 591       DrawMiniElementOrWall_MM(x, y, scroll_x, scroll_y);
 592
 593   redraw_mask |= REDRAW_FIELD;
 594 }
 595
 596 int REQ_in_range(int x, int y)
 597 {
 598   if (y > DY + 249 && y < DY + 278)
 599   {
 600     if (x > DX + 1 && x < DX + 48)
 601       return 1;
 602     else if (x > DX + 51 && x < DX + 98)
 603       return 2;
 604   }
 605
 606   return 0;
 607 }
 608
 609 Pixel ReadPixel(DrawBuffer *bitmap, int x, int y)
 610 {
 611   return GetPixel(bitmap, x, y);
 612 }
 613
 614 void SetRGB(unsigned int pixel,
 615             unsigned short red, unsigned short green, unsigned short blue)
 616 {
 617 }
 618
 619 int get_base_element(int element)
 620 {
 621   if (IS_MIRROR(element))
 622     return EL_MIRROR_START;
 623   else if (IS_MIRROR_FIXED(element))
 624     return EL_MIRROR_FIXED_START;
 625   else if (IS_POLAR(element))
 626     return EL_POLAR_START;
 627   else if (IS_POLAR_CROSS(element))
 628     return EL_POLAR_CROSS_START;
 629   else if (IS_BEAMER(element))
 630     return EL_BEAMER_RED_START + BEAMER_NR(element) * 16;
 631   else if (IS_FIBRE_OPTIC(element))
 632     return EL_FIBRE_OPTIC_START + FIBRE_OPTIC_NR(element) * 2;
 633   else if (IS_MCDUFFIN(element))
 634     return EL_MCDUFFIN_START;
 635   else if (IS_LASER(element))
 636     return EL_LASER_START;
 637   else if (IS_RECEIVER(element))
 638     return EL_RECEIVER_START;
 639   else if (IS_DF_MIRROR(element))
 640     return EL_DF_MIRROR_START;
 641   else if (IS_DF_MIRROR_AUTO(element))
 642     return EL_DF_MIRROR_AUTO_START;
 643   else if (IS_PACMAN(element))
 644     return EL_PACMAN_START;
 645   else if (IS_GRID_STEEL(element))
 646     return EL_GRID_STEEL_START;
 647   else if (IS_GRID_WOOD(element))
 648     return EL_GRID_WOOD_START;
 649   else if (IS_GRID_STEEL_FIXED(element))
 650     return EL_GRID_STEEL_FIXED_START;
 651   else if (IS_GRID_WOOD_FIXED(element))
 652     return EL_GRID_WOOD_FIXED_START;
 653   else if (IS_GRID_STEEL_AUTO(element))
 654     return EL_GRID_STEEL_AUTO_START;
 655   else if (IS_GRID_WOOD_AUTO(element))
 656     return EL_GRID_WOOD_AUTO_START;
 657   else if (IS_WALL_STEEL(element))
 658     return EL_WALL_STEEL_START;
 659   else if (IS_WALL_WOOD(element))
 660     return EL_WALL_WOOD_START;
 661   else if (IS_WALL_ICE(element))
 662     return EL_WALL_ICE_START;
 663   else if (IS_WALL_AMOEBA(element))
 664     return EL_WALL_AMOEBA_START;
 665   else if (IS_DF_WALL_STEEL(element))
 666     return EL_DF_WALL_STEEL_START;
 667   else if (IS_DF_WALL_WOOD(element))
 668     return EL_DF_WALL_WOOD_START;
 669   else if (IS_CHAR(element))
 670     return EL_CHAR_START;
 671   else
 672     return element;
 673 }
 674
 675 int get_element_phase(int element)
 676 {
 677   return element - get_base_element(element);
 678 }
 679
 680 int get_num_elements(int element)
 681 {
 682   if (IS_MIRROR(element) ||
 683       IS_POLAR(element) ||
 684       IS_BEAMER(element) ||
 685       IS_DF_MIRROR(element) ||
 686       IS_DF_MIRROR_AUTO(element))
 687     return 16;
 688   else if (IS_GRID_STEEL_FIXED(element) ||
 689            IS_GRID_WOOD_FIXED(element) ||
 690            IS_GRID_STEEL_AUTO(element) ||
 691            IS_GRID_WOOD_AUTO(element))
 692     return 8;
 693   else if (IS_MIRROR_FIXED(element) ||
 694            IS_POLAR_CROSS(element) ||
 695            IS_MCDUFFIN(element) ||
 696            IS_LASER(element) ||
 697            IS_RECEIVER(element) ||
 698            IS_PACMAN(element) ||
 699            IS_GRID_STEEL(element) ||
 700            IS_GRID_WOOD(element))
 701     return 4;
 702   else
 703     return 1;
 704 }
 705
 706 int get_rotated_element(int element, int step)
 707 {
 708   int base_element = get_base_element(element);
 709   int num_elements = get_num_elements(element);
 710   int element_phase = element - base_element;
 711
 712   return base_element + (element_phase + step + num_elements) % num_elements;
 713 }
 714
 715 static int map_element(int element)
 716 {
 717   switch (element)
 718   {
 719     case EL_WALL_STEEL:         return EL_STEEL_WALL;
 720     case EL_WALL_WOOD:          return EL_WOODEN_WALL;
 721     case EL_WALL_ICE:           return EL_ICE_WALL;
 722     case EL_WALL_AMOEBA:        return EL_AMOEBA_WALL;
 723     case EL_DF_WALL_STEEL:      return EL_DF_STEEL_WALL;
 724     case EL_DF_WALL_WOOD:       return EL_DF_WOODEN_WALL;
 725
 726     default:                    return element;
 727   }
 728 }
 729
 730 int el2gfx(int element)
 731 {
 732   element = map_element(element);
 733
 734   switch (element)
 735   {
 736     case EL_LIGHTBALL:
 737       return IMG_MM_LIGHTBALL_RED + RND(3);
 738
 739     default:
 740       return el2img_mm(element);
 741   }
 742 }
 743
 744 void RedrawPlayfield_MM()
 745 {
 746   DrawLevel_MM();
 747   DrawLaser_MM();
 748 }
 749
 750 void BlitScreenToBitmap_MM(Bitmap *target_bitmap)
 751 {
 752   BlitBitmap(drawto_field, target_bitmap,
 753              REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE, REAL_SX, REAL_SY);
 754 }