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 short 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 short 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       dx = x % MAX_BUF_XSIZE;
  91       obj = map_obj[frame][Draw[y][x]];
  92
  93       if (screentiles[dy][dx] != obj)
  94       {
  95         screentiles[dy][dx] = obj;
  96         BlitBitmap(objBitmap, screenBitmap,
  97                    (obj / 512) * TILEX, (obj % 512) * TILEY / 16,
  98                    TILEX, TILEY, dx * TILEX, dy * TILEY);
  99       }
 100     }
 101   }
 102 }
 103
 104
 105 /* blit players to the screen
 106  *
 107  * handles transparency and movement
 108  */
 109
 110 static void blitplayer(struct PLAYER *ply)
 111 {
 112   unsigned int x, y, dx, dy;
 113   unsigned short obj, spr;
 114   int src_x, src_y, dest_x, dest_y;
 115
 116   if (!ply->alive)
 117     return;
 118
 119   x = (frame * ply->oldx + (8 - frame) * ply->x) * TILEX / 8;
 120   y = (frame * ply->oldy + (8 - frame) * ply->y) * TILEY / 8;
 121   dx = x + TILEX - 1;
 122   dy = y + TILEY - 1;
 123
 124   if ((unsigned int)(dx - screen_x) < ((MAX_BUF_XSIZE - 1) * TILEX - 1) &&
 125       (unsigned int)(dy - screen_y) < ((MAX_BUF_YSIZE - 1) * TILEY - 1))
 126   {
 127     spr = map_spr[ply->num][frame][ply->anim];
 128     x %= MAX_BUF_XSIZE * TILEX;
 129     y %= MAX_BUF_YSIZE * TILEY;
 130     dx %= MAX_BUF_XSIZE * TILEX;
 131     dy %= MAX_BUF_YSIZE * TILEY;
 132
 133 #if 1
 134     /* draw the player to current location */
 135     BlitBitmap(sprBitmap, screenBitmap,
 136                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 137                x, y);
 138     /* draw the player to opposite wrap-around column */
 139     BlitBitmap(sprBitmap, screenBitmap,
 140                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 141                x - MAX_BUF_XSIZE * TILEX, y),
 142     /* draw the player to opposite wrap-around row */
 143     BlitBitmap(sprBitmap, screenBitmap,
 144                (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 145                x, y - MAX_BUF_YSIZE * TILEY);
 146
 147     /* draw the field the player is moving from (masked over the player) */
 148     obj = screentiles[y / TILEY][x / TILEX];
 149     src_x = (obj / 512) * TILEX;
 150     src_y = (obj % 512) * TILEY / 16;
 151     dest_x = (x / TILEX) * TILEX;
 152     dest_y = (y / TILEY) * TILEY;
 153
 154     SetClipOrigin(objBitmap, objBitmap->stored_clip_gc,
 155                   dest_x - src_x, dest_y - src_y);
 156     BlitBitmapMasked(objBitmap, screenBitmap,
 157                      src_x, src_y, TILEX, TILEY, dest_x, dest_y);
 158
 159     /* draw the field the player is moving to (masked over the player) */
 160     obj = screentiles[dy / TILEY][dx / TILEX];
 161     src_x = (obj / 512) * TILEX;
 162     src_y = (obj % 512) * TILEY / 16;
 163     dest_x = (dx / TILEX) * TILEX;
 164     dest_y = (dy / TILEY) * TILEY;
 165
 166     SetClipOrigin(objBitmap, objBitmap->stored_clip_gc,
 167                   dest_x - src_x, dest_y - src_y);
 168     BlitBitmapMasked(objBitmap, screenBitmap,
 169                      src_x, src_y, TILEX, TILEY, dest_x, dest_y);
 170
 171 #else
 172
 173     if (objmaskBitmap)
 174     {
 175       obj = screentiles[y / TILEY][x / TILEX];
 176       XCopyArea(display, objmaskBitmap, spriteBitmap, spriteGC,
 177                 (obj / 512) * TILEX, (obj % 512) * TILEY / 16, TILEX, TILEY,
 178                 -(x % TILEX), -(y % TILEY));
 179
 180       obj = screentiles[dy / TILEY][dx / TILEX];
 181       XCopyArea(display, objmaskBitmap, spriteBitmap, spriteGC,
 182                 (obj / 512) * TILEX, (obj % 512) * TILEY / 16, TILEX, TILEY,
 183                 (MAX_BUF_XSIZE * TILEX - x) % TILEX,
 184                 (MAX_BUF_YSIZE * TILEY - y) % TILEY);
 185     }
 186     else if (sprmaskBitmap)
 187     {
 188       XCopyArea(display, sprmaskBitmap, spriteBitmap, spriteGC,
 189                 (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY, 0, 0);
 190     }
 191     else
 192     {
 193       XFillRectangle(display, spriteBitmap, spriteGC, 0, 0, TILEX, TILEY);
 194     }
 195
 196     SetClipMask(sprBitmap, sprBitmap->stored_clip_gc, spriteBitmap);
 197
 198     SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc, x, y);
 199     BlitBitmapMasked(sprBitmap, screenBitmap,
 200                      (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 201                      x, y);
 202
 203     SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc,
 204                   x - MAX_BUF_XSIZE * TILEX, y);
 205     BlitBitmapMasked(sprBitmap, screenBitmap,
 206                      (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 207                      x - MAX_BUF_XSIZE * TILEX, y);
 208
 209     SetClipOrigin(sprBitmap, sprBitmap->stored_clip_gc,
 210                   x, y - MAX_BUF_YSIZE * TILEY);
 211     BlitBitmapMasked(sprBitmap, screenBitmap,
 212                      (spr / 8) * TILEX, (spr % 8) * TILEY, TILEX, TILEY,
 213                      x, y - MAX_BUF_YSIZE * TILEY);
 214
 215     SetClipMask(sprBitmap, sprBitmap->stored_clip_gc, None);
 216 #endif
 217
 218     screentiles[y / TILEY][x / TILEX] = -1;     /* mark screen as dirty */
 219     screentiles[dy / TILEY][dx / TILEX] = -1;
 220   }
 221 }
 222
 223 void game_initscreen(void)
 224 {
 225   unsigned int x,y;
 226
 227   frame = 6;
 228   screen_x = 0;
 229   screen_y = 0;
 230
 231   for (y = 0; y < MAX_BUF_YSIZE; y++)
 232     for (x = 0; x < MAX_BUF_XSIZE; x++)
 233       screentiles[y][x] = -1;
 234
 235   DrawGameDoorValues_EM(lev.required, ply1.dynamite, lev.score,
 236                         DISPLAY_TIME(lev.time + 4));
 237 }
 238
 239 void game_animscreen(void)
 240 {
 241   unsigned int x,y;
 242
 243   x = (frame * ply1.oldx + (8 - frame) * ply1.x) * TILEX / 8
 244     + ((SCR_FIELDX - 1) * TILEX) / 2;
 245   y = (frame * ply1.oldy + (8 - frame) * ply1.y) * TILEY / 8
 246     + ((SCR_FIELDY - 1) * TILEY) / 2;
 247
 248   if (x > lev.width * TILEX)
 249     x = lev.width * TILEX;
 250   if (y > lev.height * TILEY)
 251     y = lev.height * TILEY;
 252
 253   if (x < SCR_FIELDX * TILEX)
 254     x = SCR_FIELDX * TILEY;
 255   if (y < SCR_FIELDY * TILEY)
 256     y = SCR_FIELDY * TILEY;
 257
 258   screen_x = x - (SCR_FIELDX - 1) * TILEX;
 259   screen_y = y - (SCR_FIELDY - 1) * TILEY;
 260
 261   animscreen();
 262   blitplayer(&ply1);
 263   blitplayer(&ply2);
 264   blitscreen();
 265
 266   FlushDisplay();
 267 }