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 int gd_drawcave(Bitmap *dest, GdGame *game, boolean force_redraw)
 296 {
 297   GdCave *cave = game->cave;
 298   void (*blit_bitmap)(Bitmap *, Bitmap *, int, int, int, int, int, int) = BlitBitmap;
 299   static int show_flash_count = 0;
 300   boolean show_flash = FALSE;
 301   boolean redraw_all = force_redraw;
 302   int scroll_y_aligned = scroll_y;
 303   int x, y, xd, yd;
 304
 305   /* force redraw if maximum number of cycles has changed (to redraw moving elements) */
 306   if (game->itermax != game->itermax_last)
 307     redraw_all = TRUE;
 308
 309   if (!cave->gate_open_flash)
 310   {
 311     show_flash_count = 0;
 312   }
 313   else
 314   {
 315     if (show_flash_count++ < 4)
 316       show_flash = TRUE;
 317
 318     redraw_all = TRUE;
 319   }
 320
 321   if (show_flash)
 322   {
 323     FillRectangle(dest, 0, 0, SXSIZE, SYSIZE, WHITE_PIXEL);
 324
 325     blit_bitmap = BlitBitmapMasked;
 326     redraw_all = TRUE;
 327   }
 328
 329   /* here we draw all cells to be redrawn. we do not take scrolling area into
 330      consideration - sdl will do the clipping. */
 331   for (y = cave->y1, yd = 0; y <= cave->y2; y++, yd++)
 332   {
 333     for (x = cave->x1, xd = 0; x <= cave->x2; x++, xd++)
 334     {
 335       /* potential movement direction of game element */
 336       int dir = game->dir_buffer[y][x];
 337
 338       if (redraw_all || game->gfx_buffer[y][x] & GD_REDRAW || dir != GD_MV_STILL)
 339       {
 340         /* skip redrawing already drawn element with movement */
 341         if (game->element_buffer[y][x] & SKIPPED)
 342           continue;
 343
 344         /* if it needs to be redrawn */
 345         SDL_Rect offset;
 346
 347         /* sdl_blitsurface destroys offset, so we have to set y here, too.
 348            (ie. in every iteration) */
 349         offset.y = y * cell_size - scroll_y_aligned;
 350         offset.x = x * cell_size - scroll_x;
 351
 352         /* now we have drawn it */
 353         game->gfx_buffer[y][x] = game->gfx_buffer[y][x] & ~GD_REDRAW;
 354
 355         int tile = game->element_buffer[y][x];
 356         int frame = game->animcycle;
 357         struct GraphicInfo_BD *g = &graphic_info_bd_object[tile][frame];
 358         int width  = g->width  * TILESIZE_VAR / TILESIZE;
 359         int height = g->height * TILESIZE_VAR / TILESIZE;
 360         boolean use_smooth_movements = TRUE;
 361
 362         /* if game element is just moving, draw movement animation between two tiles */
 363         if (use_smooth_movements && dir != GD_MV_STILL)
 364         {
 365           if (!(game->last_element_buffer[y][x] & SKIPPED))
 366           {
 367             /* redraw previous game element on the cave field the new element is moving to */
 368             int tile_old = game->last_element_buffer[y][x] & ~SKIPPED;
 369             struct GraphicInfo_BD *g_old = &graphic_info_bd_object[tile_old][frame];
 370
 371             blit_bitmap(g_old->bitmap, dest, g_old->src_x, g_old->src_y, width, height,
 372                         offset.x, offset.y);
 373           }
 374
 375           /* get cave field position the game element is moving from */
 376           int dx = (dir == GD_MV_LEFT ? +1 : dir == GD_MV_RIGHT ? -1 : 0);
 377           int dy = (dir == GD_MV_UP   ? +1 : dir == GD_MV_DOWN  ? -1 : 0);
 378           int old_x = cave->getx(cave, x + dx, y + dy);
 379           int old_y = cave->gety(cave, x + dx, y + dy);
 380
 381           if (old_x >= cave->x1 &&
 382               old_x <= cave->x2 &&
 383               old_y >= cave->y1 &&
 384               old_y <= cave->y2)
 385           {
 386             if (game->dir_buffer[old_y][old_x] == GD_MV_STILL)
 387             {
 388               /* redraw game element on the cave field the element is moving from */
 389               int tile_from = game->element_buffer[old_y][old_x];
 390               struct GraphicInfo_BD *g_from = &graphic_info_bd_object[tile_from][0];
 391
 392               blit_bitmap(g_from->bitmap, dest, g_from->src_x, g_from->src_y, width, height,
 393                           offset.x + dx * cell_size, offset.y + dy * cell_size);
 394
 395               game->element_buffer[old_y][old_x] |= SKIPPED;
 396             }
 397             else
 398             {
 399               /* if old tile also moving (like pushing player), do not redraw it again */
 400               game->last_element_buffer[old_y][old_x] |= SKIPPED;
 401             }
 402           }
 403
 404           /* get shifted position between cave fields the game element is moving from/to */
 405           int itercycle = MIN(MAX(0, game->itermax - game->itercycle - 1), game->itermax);
 406           int shift = cell_size * itercycle / game->itermax;
 407
 408           offset.x += dx * shift;
 409           offset.y += dy * shift;
 410         }
 411
 412         blit_bitmap(g->bitmap, dest, g->src_x, g->src_y, width, height, offset.x, offset.y);
 413
 414 #if DO_GFX_SANITY_CHECK
 415         if (use_native_bd_graphics_engine() && !setup.small_game_graphics && !program.headless)
 416         {
 417           int old_x = (game->gfx_buffer[y][x] % GD_NUM_OF_CELLS) % GD_NUM_OF_CELLS_X;
 418           int old_y = (game->gfx_buffer[y][x] % GD_NUM_OF_CELLS) / GD_NUM_OF_CELLS_X;
 419           int new_x = g->src_x / g->width;
 420           int new_y = g->src_y / g->height;
 421
 422           if (new_x != old_x || new_y != old_y)
 423           {
 424             printf("::: BAD ANIMATION FOR TILE %d, FRAME %d [NEW(%d, %d) != OLD(%d, %d)] ['%s']\n",
 425                    tile, frame,
 426                    new_x, new_y,
 427                    old_x, old_y,
 428                    gd_elements[tile].name);
 429           }
 430         }
 431 #endif
 432       }
 433     }
 434   }
 435
 436   return 0;
 437 }