src/game_bd/bd_graphics.c

   1 /*
   2  * Copyright (c) 2007, 2008, 2009, Czirkos Zoltan <cirix@fw.hu>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <glib.h>
  18
  19 #include "main_bd.h"
  20
  21
  22 // !!! (can be removed later) !!!
  23 #define DO_GFX_SANITY_CHECK     TRUE
  24
  25 /* distance to screen edge in cells when scrolling the screen */
  26 #define SCROLL_EDGE_DISTANCE    4
  27
  28 /* these can't be larger than 31, or they mess up utf8 coding or are the same
  29    as some ascii letter */
  30 #define GD_DOWN_CHAR            1
  31 #define GD_LEFT_CHAR            2
  32 #define GD_UP_CHAR              3
  33 #define GD_RIGHT_CHAR           4
  34
  35 #define GD_BALL_CHAR            5
  36 #define GD_UNCHECKED_BOX_CHAR   6
  37 #define GD_CHECKED_BOX_CHAR     7
  38
  39 #define GD_PLAYER_CHAR          8
  40 #define GD_DIAMOND_CHAR         9
  41 #define GD_SKELETON_CHAR        11
  42 #define GD_KEY_CHAR             12
  43 #define GD_COMMENT_CHAR         13
  44
  45 /* screen area */
  46 Bitmap *gd_screen_bitmap = NULL;
  47
  48 static int play_area_w = 0;
  49 static int play_area_h = 0;
  50
  51 static int scroll_x, scroll_y;
  52
  53 /* quit, global variable which is set to true if the application should quit */
  54 boolean gd_quit = FALSE;
  55
  56 const guint8 *gd_keystate;
  57
  58 static int cell_size = 0;
  59
  60 /* graphic info for game objects/frames and players/actions/frames */
  61 struct GraphicInfo_BD graphic_info_bd_object[O_MAX_ALL][8];
  62
  63 void set_cell_size(int s)
  64 {
  65   cell_size = s;
  66 }
  67
  68 void set_play_area(int w, int h)
  69 {
  70   play_area_w = w;
  71   play_area_h = h;
  72 }
  73
  74 void gd_init_keystate(void)
  75 {
  76   set_play_area(SXSIZE, SYSIZE);
  77
  78   gd_keystate = SDL_GetKeyboardState(NULL);
  79 }
  80
  81 /*
  82   logical_size: logical pixel size of playfield, usually larger than the screen.
  83   physical_size: visible part. (remember: player_x-x1!)
  84
  85   center: the coordinates to scroll to.
  86   exact: scroll exactly
  87   start: start scrolling if difference is larger than
  88   to: scroll to, if started, until difference is smaller than
  89   current
  90
  91   desired: the function stores its data here
  92   speed: the function stores its data here
  93
  94   cell_size: size of one cell. used to determine if the play field is only a
  95   slightly larger than the screen, in that case no scrolling is desirable
  96 */
  97 static boolean cave_scroll(int logical_size, int physical_size, int center, boolean exact,
  98                            int *current, int *desired, int speed)
  99 {
 100   int max = MAX(0, logical_size - physical_size);
 101   int edge_distance = SCROLL_EDGE_DISTANCE;
 102   int cell_size = TILESIZE_VAR;
 103   boolean changed = FALSE;
 104
 105   /* start scrolling when player reaches certain distance to screen edge */
 106   int start = physical_size / 2 - cell_size * edge_distance;
 107
 108   /* scroll so that the player is at the center; the allowed difference is this */
 109   int to = cell_size;
 110
 111   /* if cave size smaller than the screen, no scrolling req'd */
 112   if (logical_size < physical_size)
 113   {
 114     *desired = 0;
 115
 116     if (*current != 0)
 117     {
 118       *current = 0;
 119       changed = TRUE;
 120     }
 121
 122     return changed;
 123   }
 124
 125   if (logical_size <= physical_size + cell_size)
 126   {
 127     /* if cave size is only a slightly larger than the screen, also no scrolling */
 128     /* scroll to the middle of the cell */
 129     *desired = max / 2;
 130   }
 131   else
 132   {
 133     if (exact)
 134     {
 135       /* if exact scrolling, just go exactly to the center. */
 136       *desired = center;
 137     }
 138     else
 139     {
 140       /* hystheresis function.
 141        * when scrolling left, always go a bit less left than player being at the middle.
 142        * when scrolling right, always go a bit less to the right. */
 143       if (*current < center - start)
 144         *desired = center - to;
 145       if (*current > center + start)
 146         *desired = center + to;
 147     }
 148   }
 149
 150   *desired = MIN(MAX(0, *desired), max);
 151
 152   if (*current < *desired)
 153   {
 154     *current = MIN(*current + speed, *desired);
 155
 156     changed = TRUE;
 157   }
 158
 159   if (*current > *desired)
 160   {
 161     *current = MAX(*current - speed, *desired);
 162
 163     changed = TRUE;
 164   }
 165
 166   return changed;
 167 }
 168
 169 /* just set current viewport to upper left. */
 170 void gd_scroll_to_origin(void)
 171 {
 172   scroll_x = 0;
 173   scroll_y = 0;
 174 }
 175
 176 int get_scroll_x(void)
 177 {
 178   return scroll_x / cell_size;
 179 }
 180
 181 int get_scroll_y(void)
 182 {
 183   return scroll_y / cell_size;
 184 }
 185
 186 int get_play_area_w(void)
 187 {
 188   return play_area_w / cell_size;
 189 }
 190
 191 int get_play_area_h(void)
 192 {
 193   return play_area_h / cell_size;
 194 }
 195
 196 /* SCROLLING
 197  *
 198  * scrolls to the player during game play.
 199  * called by drawcave
 200  * returns true, if player is not visible-ie it is out of the visible size in the drawing area.
 201  */
 202 boolean gd_scroll(GdGame *game, boolean exact_scroll, boolean immediate)
 203 {
 204   static int scroll_desired_x = 0, scroll_desired_y = 0;
 205   boolean out_of_window;
 206   int player_x, player_y, visible_x, visible_y;
 207   boolean changed;
 208   int scroll_divisor;
 209
 210   /* max scrolling speed depends on the speed of the cave. */
 211   /* game moves cell_size_game * 1s / cave time pixels in a second. */
 212   /* scrolling moves scroll speed * 1s / scroll_time in a second. */
 213   /* these should be almost equal; scrolling speed a little slower. */
 214   /* that way, the player might reach the border with a small probability, */
 215   /* but the scrolling will not "oscillate", ie. turn on for little intervals as it has */
 216   /* caught up with the desired position. smaller is better. */
 217   int scroll_speed = cell_size * 20 / game->cave->speed;
 218
 219   if (immediate)
 220     scroll_speed = cell_size * MAX(game->cave->w, game->cave->h);
 221
 222   player_x = game->cave->player_x - game->cave->x1; /* cell coordinates of player */
 223   player_y = game->cave->player_y - game->cave->y1;
 224
 225   /* pixel size of visible part of the cave (may be smaller in intermissions) */
 226   visible_x = (game->cave->x2 - game->cave->x1 + 1) * cell_size;
 227   visible_y = (game->cave->y2 - game->cave->y1 + 1) * cell_size;
 228
 229   /* cell_size contains the scaled size, but we need the original. */
 230   changed = FALSE;
 231
 232   /* some sort of scrolling speed.
 233      with larger cells, the divisor must be smaller, so the scrolling faster. */
 234   scroll_divisor = 256 / cell_size;
 235
 236   /* fine scrolling is 50hz (normal would be 25hz only) */
 237   scroll_divisor *= 2;
 238
 239   if (cave_scroll(visible_x, play_area_w, player_x * cell_size + cell_size / 2 - play_area_w / 2,
 240                   exact_scroll, &scroll_x, &scroll_desired_x, scroll_speed))
 241     changed = TRUE;
 242
 243   if (cave_scroll(visible_y, play_area_h, player_y * cell_size + cell_size / 2 - play_area_h / 2,
 244                   exact_scroll, &scroll_y, &scroll_desired_y, scroll_speed))
 245     changed = TRUE;
 246
 247   /* if scrolling, we should update entire screen. */
 248   if (changed)
 249   {
 250     int x, y;
 251
 252     for (y = 0; y < game->cave->h; y++)
 253       for (x = 0; x < game->cave->w; x++)
 254         game->gfx_buffer[y][x] |= GD_REDRAW;
 255   }
 256
 257   /* check if active player is visible at the moment. */
 258   out_of_window = FALSE;
 259
 260   /* check if active player is outside drawing area. if yes, we should wait for scrolling */
 261   if ((player_x * cell_size) < scroll_x ||
 262       (player_x * cell_size + cell_size - 1) > scroll_x + play_area_w)
 263   {
 264     /* but only do the wait, if the player SHOULD BE visible, ie. he is inside
 265        the defined visible area of the cave */
 266     if (game->cave->player_x >= game->cave->x1 &&
 267         game->cave->player_x <= game->cave->x2)
 268       out_of_window = TRUE;
 269   }
 270
 271   if ((player_y * cell_size) < scroll_y ||
 272       (player_y * cell_size + cell_size - 1) > scroll_y + play_area_h)
 273     /* but only do the wait, if the player SHOULD BE visible, ie. he is inside
 274        the defined visible area of the cave */
 275     if (game->cave->player_y >= game->cave->y1 &&
 276         game->cave->player_y <= game->cave->y2)
 277       out_of_window = TRUE;
 278
 279   /* if not yet born, we treat as visible. so cave will run.
 280      the user is unable to control an unborn player, so this is the right behaviour. */
 281   if (game->cave->player_state == GD_PL_NOT_YET)
 282     return FALSE;
 283
 284   return out_of_window;
 285 }
 286
 287 #if DO_GFX_SANITY_CHECK
 288 /* workaround to prevent variable name scope problem */
 289 static boolean use_native_bd_graphics_engine(void)
 290 {
 291   return game.use_native_bd_graphics_engine;
 292 }
 293 #endif
 294
 295 /* returns true if the element is a player */
 296 static inline boolean is_player(const int element)
 297 {
 298   return (gd_elements[element & O_MASK].properties & P_PLAYER) != 0;
 299 }
 300
 301 /* returns true if the element is collectible */
 302 static inline boolean is_collectible(const int element)
 303 {
 304   return (gd_elements[element & O_MASK].properties & P_COLLECTIBLE) != 0;
 305 }
 306
 307 int gd_drawcave(Bitmap *dest, GdGame *game, boolean force_redraw)
 308 {
 309   GdCave *cave = game->cave;
 310   void (*blit_bitmap)(Bitmap *, Bitmap *, int, int, int, int, int, int) = BlitBitmap;
 311   static int show_flash_count = 0;
 312   boolean show_flash = FALSE;
 313   boolean redraw_all = force_redraw;
 314   int scroll_y_aligned = scroll_y;
 315   int x, y;
 316
 317   /* force redraw if maximum number of cycles has changed (to redraw moving elements) */
 318   if (game->itermax != game->itermax_last)
 319     redraw_all = TRUE;
 320
 321   if (!cave->gate_open_flash)
 322   {
 323     show_flash_count = 0;
 324   }
 325   else
 326   {
 327     if (show_flash_count++ < 4)
 328       show_flash = TRUE;
 329
 330     redraw_all = TRUE;
 331   }
 332
 333   if (show_flash)
 334   {
 335     FillRectangle(dest, 0, 0, SXSIZE, SYSIZE, WHITE_PIXEL);
 336
 337     blit_bitmap = BlitBitmapMasked;
 338     redraw_all = TRUE;
 339   }
 340
 341   /* here we draw all cells to be redrawn. we do not take scrolling area into
 342      consideration - sdl will do the clipping. */
 343   for (y = cave->y1; y <= cave->y2; y++)
 344   {
 345     for (x = cave->x1; x <= cave->x2; x++)
 346     {
 347       /* potential movement direction of game element */
 348       int dir = game->dir_buffer[y][x];
 349
 350       if (redraw_all || game->gfx_buffer[y][x] & GD_REDRAW || dir != GD_MV_STILL)
 351       {
 352         /* skip redrawing already drawn element with movement */
 353         if (game->element_buffer[y][x] & SKIPPED)
 354           continue;
 355
 356         /* now we have drawn it */
 357         game->gfx_buffer[y][x] = game->gfx_buffer[y][x] & ~GD_REDRAW;
 358
 359         int sx = x * cell_size - scroll_x;
 360         int sy = y * cell_size - scroll_y_aligned;
 361         int tile = game->element_buffer[y][x];
 362         int frame = game->animcycle;
 363         struct GraphicInfo_BD *g = &graphic_info_bd_object[tile][frame];
 364         boolean use_smooth_movements = TRUE;
 365
 366         /* if game element is just moving, draw movement animation between two tiles */
 367         if (use_smooth_movements && dir != GD_MV_STILL)
 368         {
 369           if (!(game->last_element_buffer[y][x] & SKIPPED))
 370           {
 371             /* redraw previous game element on the cave field the new element is moving to */
 372             int tile_old = game->last_element_buffer[y][x];
 373
 374             /* only redraw previous game element if it is not collectible (like dirt etc.) */
 375             if (is_collectible(tile_old))
 376               tile_old = O_SPACE;
 377
 378             struct GraphicInfo_BD *g_old = &graphic_info_bd_object[tile_old][frame];
 379
 380             blit_bitmap(g_old->bitmap, dest, g_old->src_x, g_old->src_y, cell_size, cell_size,
 381                         sx, sy);
 382           }
 383
 384           /* get cave field position the game element is moving from */
 385           int dx = (dir == GD_MV_LEFT ? +1 : dir == GD_MV_RIGHT ? -1 : 0);
 386           int dy = (dir == GD_MV_UP   ? +1 : dir == GD_MV_DOWN  ? -1 : 0);
 387           int old_x = cave->getx(cave, x + dx, y + dy);
 388           int old_y = cave->gety(cave, x + dx, y + dy);
 389           int tile_from = game->element_buffer[old_y][old_x];
 390           struct GraphicInfo_BD *g_from = &graphic_info_bd_object[tile_from][frame];
 391           boolean old_is_player = is_player(tile_from);
 392           boolean old_is_moving = (game->dir_buffer[old_y][old_x] != GD_MV_STILL);
 393           boolean old_is_visible = (old_x >= cave->x1 &&
 394                                     old_x <= cave->x2 &&
 395                                     old_y >= cave->y1 &&
 396                                     old_y <= cave->y2);
 397
 398           if (old_is_visible)
 399           {
 400             if (!old_is_moving && !old_is_player)
 401             {
 402               /* redraw game element on the cave field the element is moving from */
 403               blit_bitmap(g_from->bitmap, dest, g_from->src_x, g_from->src_y, cell_size, cell_size,
 404                           sx + dx * cell_size, sy + dy * cell_size);
 405
 406               game->element_buffer[old_y][old_x] |= SKIPPED;
 407             }
 408             else
 409             {
 410               /* if old tile also moving (like pushing player), do not redraw tile background */
 411               game->last_element_buffer[old_y][old_x] |= SKIPPED;
 412             }
 413           }
 414
 415           /* get shifted position between cave fields the game element is moving from/to */
 416           int itercycle = MIN(MAX(0, game->itermax - game->itercycle - 1), game->itermax);
 417           int shift = cell_size * itercycle / game->itermax;
 418
 419           blit_bitmap(g->bitmap, dest, g->src_x, g->src_y, cell_size, cell_size,
 420                       sx + dx * shift, sy + dy * shift);
 421
 422           /* special case: redraw player snapping a game element */
 423           if (old_is_visible && old_is_player && !old_is_moving)
 424           {
 425             /* redraw game element on the cave field the element is moving from */
 426             blit_bitmap(g_from->bitmap, dest, g_from->src_x, g_from->src_y, cell_size, cell_size,
 427                         sx + dx * cell_size, sy + dy * cell_size);
 428           }
 429         }
 430         else
 431         {
 432           blit_bitmap(g->bitmap, dest, g->src_x, g->src_y, cell_size, cell_size, sx, sy);
 433         }
 434
 435 #if DO_GFX_SANITY_CHECK
 436         if (use_native_bd_graphics_engine() && !setup.small_game_graphics && !program.headless)
 437         {
 438           int old_x = (game->gfx_buffer[y][x] % GD_NUM_OF_CELLS) % GD_NUM_OF_CELLS_X;
 439           int old_y = (game->gfx_buffer[y][x] % GD_NUM_OF_CELLS) / GD_NUM_OF_CELLS_X;
 440           int new_x = g->src_x / g->width;
 441           int new_y = g->src_y / g->height;
 442
 443           if (new_x != old_x || new_y != old_y)
 444           {
 445             printf("::: BAD ANIMATION FOR TILE %d, FRAME %d [NEW(%d, %d) != OLD(%d, %d)] ['%s']\n",
 446                    tile, frame,
 447                    new_x, new_y,
 448                    old_x, old_y,
 449                    gd_elements[tile].name);
 450           }
 451         }
 452 #endif
 453       }
 454     }
 455   }
 456
 457   return 0;
 458 }