src/game_em/graphics.c

   1 /* 2000-08-13T14:36:17Z
   2  *
   3  * graphics manipulation crap
   4  */
   5
   6 #include "global.h"
   7 #include "display.h"
   8 #include "level.h"
   9
  10
  11 unsigned int frame;             /* current screen frame */
  12 unsigned int screen_x;          /* current scroll position */
  13 unsigned int screen_y;
  14
  15 /* tiles currently on screen */
  16 static unsigned int screentiles[MAX_BUF_YSIZE][MAX_BUF_XSIZE];
  17
  18
  19 /* copy the entire screen to the window at the scroll position
  20  *
  21  * perhaps use mit-shm to speed this up
  22  */
  23
  24 void blitscreen(void)
  25 {
  26   unsigned int x = screen_x % (MAX_BUF_XSIZE * TILEX);
  27   unsigned int y = screen_y % (MAX_BUF_YSIZE * TILEY);
  28
  29   if (x < 2 * TILEX && y < 2 * TILEY)
  30   {
  31     BlitBitmap(screenBitmap, window, x, y,
  32                SCR_FIELDX * TILEX, SCR_FIELDY * TILEY, SX, SY);
  33   }
  34   else if (x < 2 * TILEX && y >= 2 * TILEY)
  35   {
  36     BlitBitmap(screenBitmap, window, x, y,
  37                SCR_FIELDX * TILEX, MAX_BUF_YSIZE * TILEY - y,
  38                SX, SY);
  39     BlitBitmap(screenBitmap, window, x, 0,
  40                SCR_FIELDX * TILEX, y - 2 * TILEY,
  41                SX, SY + MAX_BUF_YSIZE * TILEY - y);
  42   }
  43   else if (x >= 2 * TILEX && y < 2 * TILEY)
  44   {
  45     BlitBitmap(screenBitmap, window, x, y,
  46                MAX_BUF_XSIZE * TILEX - x, SCR_FIELDY * TILEY,
  47                SX, SY);
  48     BlitBitmap(screenBitmap, window, 0, y,
  49                x - 2 * TILEX, SCR_FIELDY * TILEY,
  50                SX + MAX_BUF_XSIZE * TILEX - x, SY);
  51   }
  52   else
  53   {
  54     BlitBitmap(screenBitmap, window, x, y,
  55                MAX_BUF_XSIZE * TILEX - x, MAX_BUF_YSIZE * TILEY - y,
  56                SX, SY);
  57     BlitBitmap(screenBitmap, window, 0, y,
  58                x - 2 * TILEX, MAX_BUF_YSIZE * TILEY - y,
  59                SX + MAX_BUF_XSIZE * TILEX - x, SY);
  60     BlitBitmap(screenBitmap, window, x, 0,
  61                MAX_BUF_XSIZE * TILEX - x, y - 2 * TILEY,
  62                SX, SY + MAX_BUF_YSIZE * TILEY - y);
  63     BlitBitmap(screenBitmap, window, 0, 0,
  64                x - 2 * TILEX, y - 2 * TILEY,
  65                SX + MAX_BUF_XSIZE * TILEX - x, SY + MAX_BUF_YSIZE * TILEY - y);
  66   }
  67 }
  68
  69
  70 /* draw differences between game tiles and screen tiles
  71  *
  72  * implicitly handles scrolling and restoring background under the sprites
  73  *
  74  * perhaps use mit-shm to speed this up
  75  */
  76
  77 static void animscreen(void)
  78 {
  79   unsigned int x, y, dx, dy;
  80   unsigned int obj;
  81   unsigned int left = screen_x / TILEX;
  82   unsigned int top = screen_y / TILEY;
  83
  84   for (y = top; y < top + MAX_BUF_YSIZE; y++)
  85   {
  86     dy = y % MAX_BUF_YSIZE;
  87
  88     for (x = left; x < left + MAX_BUF_XSIZE; x++)
  89     {
  90       int tile = Draw[y][x];
  91       struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
  92
  93       dx = x % MAX_BUF_XSIZE;
  94
  95 #if 1
  96       /* create unique graphic identifier to decide if tile must be redrawn */
  97       obj = g->unique_identifier;
  98
  99       if (1 || screentiles[dy][dx] != obj)
 100       {
 101         int dst_x = dx * TILEX;
 102         int dst_y = dy * TILEY;
 103
 104         if (g->width != TILEX || g->height != TILEY)
 105           ClearRectangle(screenBitmap, dst_x, dst_y, TILEX, TILEY);
 106
 107         if (g->width > 0 && g->height > 0)
 108           BlitBitmap(g->bitmap, screenBitmap,
 109                      g->src_x + g->src_offset_x, g->src_y + g->src_offset_y,
 110                      g->width, g->height,
 111                      dst_x + g->dst_offset_x, dst_y + g->dst_offset_y);
 112
 113         screentiles[dy][dx] = obj;
 114       }
 115 #else
 116       obj = map_obj[frame][tile];
 117
 118       if (screentiles[dy][dx] != obj)
 119       {
 120         BlitBitmap(objBitmap, screenBitmap,
 121                    (obj / 512) * TILEX, (obj % 512) * TILEY / 16,
 122                    TILEX, TILEY, dx * TILEX, dy * TILEY);
 123
 124         screentiles[dy][dx] = obj;
 125       }
 126 #endif
 127     }
 128   }
 129 }
 130
 131
 132 /* blit players to the screen
 133  *
 134  * handles transparency and movement
 135  */
 136
 137 static void blitplayer(struct PLAYER *ply)
 138 {
 139   int dx, dy;
 140   int old_x, old_y, new_x, new_y;
 141   int src_x, src_y, dst_x, dst_y;
 142   unsigned int x1, y1, x2, y2;
 143 #if 1
 144   unsigned short spr;
 145 #else
 146   unsigned short obj, spr;
 147 #endif
 148
 149   if (!ply->alive)
 150     return;
 151
 152   /* some casts to "int" are needed because of negative calculation values */
 153   dx = (int)ply->x - (int)ply->oldx;
 154   dy = (int)ply->y - (int)ply->oldy;
 155   old_x = (int)ply->oldx + (7 - (int)frame) * dx / 8;
 156   old_y = (int)ply->oldy + (7 - (int)frame) * dy / 8;
 157   new_x = old_x + SIGN(dx);
 158   new_y = old_y + SIGN(dy);
 159
 160   /* x1/y1 are left/top and x2/y2 are right/down part of the player movement */
 161   x1 = (frame * ply->oldx + (8 - frame) * ply->x) * TILEX / 8;
 162   y1 = (frame * ply->oldy + (8 - frame) * ply->y) * TILEY / 8;
 163   x2 = x1 + TILEX - 1;
 164   y2 = y1 + TILEY - 1;
 165
 166   if ((unsigned int)(x2 - screen_x) < ((MAX_BUF_XSIZE - 1) * TILEX - 1) &&
 167       (unsigned int)(y2 - screen_y) < ((MAX_BUF_YSIZE - 1) * TILEY - 1))
 168   {
 169     struct GraphicInfo_EM *g;
 170     int tile;
 171
 172     spr = map_spr[ply->num][frame][ply->anim];
 173     x1 %= MAX_BUF_XSIZE * TILEX;
 174     y1 %= MAX_BUF_YSIZE * TILEY;
 175     x2 %= MAX_BUF_XSIZE * TILEX;
 176     y2 %= MAX_BUF_YSIZE * TILEY;
 177
 178 #if 1
 179
 180 #if 1
 181     g = &graphic_info_em_player[ply->num][ply->anim][frame];
 182
 183     /* draw the player to current location */
 184     BlitBitmap(g->bitmap, screenBitmap,
 185                g->src_x, g->src_y, TILEX, TILEY,
 186                x1, y1);
 187
 188     /* draw the player to opposite wrap-around column */
 189     BlitBitmap(g->bitmap, screenBitmap,
 190                g->src_x, g->src_y, TILEX, TILEY,
 191                x1 - MAX_BUF_XSIZE * TILEX, y1);
 192
 193     /* draw the player to opposite wrap-around row */
 194     BlitBitmap(g->bitmap, screenBitmap,
 195                g->src_x, g->src_y, TILEX, TILEY,
 196                x1, y1 - MAX_BUF_YSIZE * TILEY);
 197 #else
 198     /* draw the player to current location */
 199     BlitBitmap(sprBitmap, screenBitmap,
 200                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 201                x1, y1);
 202
 203     /* draw the player to opposite wrap-around column */
 204     BlitBitmap(sprBitmap, screenBitmap,
 205                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 206                x1 - MAX_BUF_XSIZE * TILEX, y1);
 207
 208     /* draw the player to opposite wrap-around row */
 209     BlitBitmap(sprBitmap, screenBitmap,
 210                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 211                x1, y1 - MAX_BUF_YSIZE * TILEY);
 212 #endif
 213
 214     /* draw the field the player is moving from (masked over the player) */
 215 #if 0
 216     obj = screentiles[y1 / TILEY][x1 / TILEX];
 217     src_x = (obj / 512) * TILEX;
 218     src_y = (obj % 512) * TILEY / 16;
 219     dst_x = (x1 / TILEX) * TILEX;
 220     dst_y = (y1 / TILEY) * TILEY;
 221 #endif
 222
 223 #if 1
 224     tile = Draw[old_y][old_x];
 225     g = &graphic_info_em_object[tile][frame];
 226
 227     if (g->width > 0 && g->height > 0)
 228     {
 229       src_x = g->src_x + g->src_offset_x;
 230       src_y = g->src_y + g->src_offset_y;
 231       dst_x = old_x % MAX_BUF_XSIZE * TILEX + g->dst_offset_x;
 232       dst_y = old_y % MAX_BUF_YSIZE * TILEY + g->dst_offset_y;
 233
 234       SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
 235                     dst_x - src_x, dst_y - src_y);
 236       BlitBitmapMasked(g->bitmap, screenBitmap,
 237                        src_x, src_y, g->width, g->height, dst_x, dst_y);
 238     }
 239 #else
 240     SetClipOrigin(objBitmap, objBitmap->stored_clip_gc,
 241                   dst_x - src_x, dst_y - src_y);
 242     BlitBitmapMasked(objBitmap, screenBitmap,
 243                      src_x, src_y, TILEX, TILEY, dst_x, dst_y);
 244 #endif
 245
 246     /* draw the field the player is moving to (masked over the player) */
 247 #if 0
 248     obj = screentiles[y2 / TILEY][x2 / TILEX];
 249     src_x = (obj / 512) * TILEX;
 250     src_y = (obj % 512) * TILEY / 16;
 251     dst_x = (x2 / TILEX) * TILEX;
 252     dst_y = (y2 / TILEY) * TILEY;
 253 #endif
 254
 255 #if 1
 256     tile = Draw[new_y][new_x];
 257     g = &graphic_info_em_object[tile][frame];
 258
 259     if (g->width > 0 && g->height > 0)
 260     {
 261       src_x = g->src_x + g->src_offset_x;
 262       src_y = g->src_y + g->src_offset_y;
 263       dst_x = new_x % MAX_BUF_XSIZE * TILEX + g->dst_offset_x;
 264       dst_y = new_y % MAX_BUF_YSIZE * TILEY + g->dst_offset_y;
 265
 266       SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
 267                     dst_x - src_x, dst_y - src_y);
 268       BlitBitmapMasked(g->bitmap, screenBitmap,
 269                        src_x, src_y, g->width, g->height, dst_x, dst_y);
 270     }
 271 #else
 272     SetClipOrigin(objBitmap, objBitmap->stored_clip_gc,
 273                   dst_x - src_x, dst_y - src_y);
 274     BlitBitmapMasked(objBitmap, screenBitmap,
 275                      src_x, src_y, TILEX, TILEY, dst_x, dst_y);
 276 #endif
 277
 278 #else
 279
 280     if (objmaskBitmap)
 281     {
 282       obj = screentiles[y1 / TILEY][x1 / TILEX];
 283       XCopyArea(display, objmaskBitmap, spriteBitmap, spriteGC,
 284                 (obj / 512) * TILEX, (obj % 512) * TILEY / 16, TILEX, TILEY,
 285                 -(x1 % TILEX), -(y1 % TILEY));
 286
 287       obj = screentiles[y2 / TILEY][x2 / TILEX];
 288       XCopyArea(display, objmaskBitmap, spriteBitmap, spriteGC,
 289                 (obj / 512) * TILEX, (obj % 512) * TILEY / 16, TILEX, TILEY,
 290                 (MAX_BUF_XSIZE * TILEX - x1) % TILEX,
 291                 (MAX_BUF_YSIZE * TILEY - y1) % TILEY);
 292     }
 293     else if (sprmaskBitmap)
 294     {
 295       XCopyArea(display, sprmaskBitmap, spriteBitmap, spriteGC,
 296                 (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY, 0, 0);
 297     }
 298     else
 299     {
 300       XFillRectangle(display, spriteBitmap, spriteGC, 0, 0, TILEX, TILEY);
 301     }
 302
 303     SetClipMask(sprBitmap, sprBitmap->stored_clip_gc, spriteBitmap);
 304
 305     SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc, x, y);
 306     BlitBitmapMasked(sprBitmap, screenBitmap,
 307                      (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 308                      x1, y1);
 309
 310     SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc,
 311                   x - MAX_BUF_XSIZE * TILEX, y);
 312     BlitBitmapMasked(sprBitmap, screenBitmap,
 313                      (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 314                      x1 - MAX_BUF_XSIZE * TILEX, y1);
 315
 316     SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc,
 317                   x1, y1 - MAX_BUF_YSIZE * TILEY);
 318     BlitBitmapMasked(sprBitmap, screenBitmap,
 319                      (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 320                      x1, y1 - MAX_BUF_YSIZE * TILEY);
 321
 322     SetClipMask(sprBitmap, sprBitmap->stored_clip_gc, None);
 323 #endif
 324
 325     /* mark screen tiles as dirty */
 326     screentiles[y1 / TILEY][x1 / TILEX] = -1;
 327     screentiles[y2 / TILEY][x2 / TILEX] = -1;
 328   }
 329 }
 330
 331 void game_initscreen(void)
 332 {
 333   unsigned int x,y;
 334
 335   frame = 6;
 336   screen_x = 0;
 337   screen_y = 0;
 338
 339   for (y = 0; y < MAX_BUF_YSIZE; y++)
 340     for (x = 0; x < MAX_BUF_XSIZE; x++)
 341       screentiles[y][x] = -1;
 342
 343   DrawGameDoorValues_EM(lev.required, ply1.dynamite, lev.score,
 344                         DISPLAY_TIME(lev.time + 4));
 345 }
 346
 347 void game_animscreen(void)
 348 {
 349   unsigned int x,y;
 350
 351   x = (frame * ply1.oldx + (8 - frame) * ply1.x) * TILEX / 8
 352     + ((SCR_FIELDX - 1) * TILEX) / 2;
 353   y = (frame * ply1.oldy + (8 - frame) * ply1.y) * TILEY / 8
 354     + ((SCR_FIELDY - 1) * TILEY) / 2;
 355
 356   if (x > lev.width * TILEX)
 357     x = lev.width * TILEX;
 358   if (y > lev.height * TILEY)
 359     y = lev.height * TILEY;
 360
 361   if (x < SCR_FIELDX * TILEX)
 362     x = SCR_FIELDX * TILEY;
 363   if (y < SCR_FIELDY * TILEY)
 364     y = SCR_FIELDY * TILEY;
 365
 366   screen_x = x - (SCR_FIELDX - 1) * TILEX;
 367   screen_y = y - (SCR_FIELDY - 1) * TILEY;
 368
 369   animscreen();
 370   blitplayer(&ply1);
 371   blitplayer(&ply2);
 372   blitscreen();
 373
 374   FlushDisplay();
 375 }