/*
* src/draw.c
*
* Copyright (C) 1998-2002 BigOrno (bigorno@bigorno.net). All rights reserved.
*
* The use and distribution terms for this software are contained in the file
* named README, which can be found in the root of this distribution. By
* using this software in any fashion, you are agreeing to be bound by the
* terms of this license.
*
* You must not remove this notice, or any other, from this software.
*/
/*
* NOTES
*
* This is the only file which accesses the video. Anything calling d_*
* function should be video-independant.
*
* draw.c draws into a 320x200 or 0x0140x0xc8 8-bits depth frame buffer,
* using the CGA 2 bits color codes. It is up to the video to figure out
* how to display the frame buffer. Whatever draw.c does, does not show
* until the screen is explicitely refreshed.
*
* The "screen" is the whole 0x0140 by 0x00c8 screen, coordinates go from
* 0x0000,0x0000 to 0x013f,0x00c7.
*
* The "map" is a 0x0100 by 0x0140 rectangle that represents the active
* game area.
*
* Relative to the screen, the "map" is located at 0x0020,-0x0040 : the
* "map" is composed of two hidden 0x0100 by 0x0040 rectangles (one at the
* top and one at the bottom) and one visible 0x0100 by 0x00c0 rectangle (in
* the middle).
*
* The "map screen" is the visible rectangle ; it is a 0x0100 by 0xc0
* rectangle located at 0x0020,0x00.
*
* Coordinates can be relative to the screen, the map, or the map screen.
*
* Coordinates can be expressed in pixels. When relative to the map or the
* map screen, they can also be expressed in tiles, the map being composed
* of rows of 0x20 tiles of 0x08 by 0x08 pixels.
*/
#include "system.h"
#include "game.h"
#include "draw.h"
#include "sysvid.h"
#include "sprites.h"
#include "tiles.h"
#include "maps.h"
#include "rects.h"
#include "img.h"
/*
* counters positions (pixels, screen)
*/
#define DRAW_STATUS_BULLETS_X 0x68
#define DRAW_STATUS_BOMBS_X 0xA8
#define DRAW_STATUS_SCORE_X 0x28
#define DRAW_STATUS_LIVES_X 0xE8
#define DRAW_STATUS_Y 8
/*
* public vars
*/
U8 *draw_tllst; /* pointer to tiles list */
U8 draw_tilesBank; /* tile number offset */
rect_t draw_STATUSRECT =
{
DRAW_STATUS_SCORE_X,
DRAW_STATUS_Y,
DRAW_STATUS_LIVES_X + 6 * 8 - DRAW_STATUS_SCORE_X,
8,
NULL
};
rect_t draw_SCREENRECT =
{
0,
0,
320,
200,
NULL
};
/*
* private vars
*/
static U8 *fb; /* frame buffer pointer */
/*
* Set the frame buffer pointer
*
* x, y: position (pixels, screen)
*/
void draw_setfb (U32 x, U32 y)
{
fb = sysvid_fb + x + 320 * y;
}
/*
* Clip to map screen
*
* x, y: position (pixels, map) CHANGED clipped
* width, height: dimension CHANGED clipped
* return: TRUE if fully clipped, FALSE if still (at least partly) visible
*/
U8 draw_clipms (S16 *x, S16 *y, U16 *width, U16 *height)
{
if (*x < 0)
{
if (*x + *width < 0)
return TRUE;
else
{
*width += *x;
*x = 0;
}
}
else
{
if (*x > 0x0100)
return TRUE;
else if (*x + *width > 0x0100)
*width = 0x0100 - *x;
}
if (*y < DRAW_XYMAP_SCRTOP)
{
if ((*y + *height) < DRAW_XYMAP_SCRTOP)
return TRUE;
else
{
*height += *y - DRAW_XYMAP_SCRTOP;
*y = DRAW_XYMAP_SCRTOP;
}
}
else
{
if (*y >= DRAW_XYMAP_HBTOP)
return TRUE;
else if (*y + *height > DRAW_XYMAP_HBTOP)
*height = DRAW_XYMAP_HBTOP - *y;
}
return FALSE;
}
/*
* Draw a list of tiles onto the frame buffer
* start at position indicated by fb ; at the end of each (sub)list,
* perform a "carriage return + line feed" i.e. go back to the initial
* position then go down one tile row (8 pixels)
*
* ASM 1e33
* fb: CHANGED (see above)
* draw_tllst: CHANGED points to the element following 0xfe/0xff end code
*/
void draw_tilesList (void)
{
U8 *t;
t = fb;
while (draw_tilesSubList () != 0xFE)
{
// draw sub-list
t += 8 * 320; // go down one tile i.e. 8 lines
fb = t;
}
}
/*
* Draw a list of tiles onto the frame buffer -- same as draw_tilesList,
* but accept an immediate string as parameter. Note that the string needs
* to be properly terminated with 0xfe (\376) and 0xff (\377) chars.
*/
void draw_tilesListImm (U8 *list)
{
draw_tllst = list;
draw_tilesList ();
}
/*
* Draw a sub-list of tiles onto the frame buffer
* start at position indicated by fb ; leave fb pointing to the next
* tile to the right of the last tile drawn
*
* ASM 1e41
* fpb: CHANGED (see above)
* draw_tllst: CHANGED points to the element following 0xfe/0xff end code
* returns: end code (0xfe : end of list ; 0xff : end of sub-list)
*/
U8 draw_tilesSubList (void)
{
U8 i;
i = *(draw_tllst++);
while (i != 0xFF && i != 0xFE)
{
/* while not end */
draw_tile (i); // draw tile
i = *(draw_tllst++);
}
return i;
}
/*
* Draw a tile
* at position indicated by fb ; leave fb pointing to the next tile
* to the right of the tile drawn
*
* ASM 1e6c
* tlnbr: tile number
* draw_filter: CGA colors filter
* fb: CHANGED (see above)
*/
void draw_tile (U8 tileNumber)
{
U8 i, k, *f;
U32 x;
f = fb; // frame buffer
for (i = 0; i < 8; i++)
{
/* for all 8 pixel lines */
x = tiles_data[draw_tilesBank][tileNumber][i];
/*
* tiles / perform the transformation from ST 4 bits
* per pixel to frame buffer 8 bits per pixels
*/
for (k = 8; k--; x >>= 4)
f[k] = (U8) x & 0x0F;
f += 320; /* next line */
}
fb += 8; /* next tile */
}
/*
* Draw a sprite
*
* ASM 1a09
* nbr: sprite number
* x, y: sprite position (pixels, screen)
* fb: CHANGED
*/
void draw_sprite (U8 number, U16 x, U16 y)
{
U8 i, j, k, *f;
U16 g;
U32 d;
draw_setfb (x, y);
g = 0;
for (i = 0; i < 0x15; i++)
{
/* rows */
f = fb;
for (j = 0; j < 4; j++)
{
/* cols */
d = sprites_data[number][g++];
/*
* sprites / perform the transformation from ST 4 bits
* per pixel to frame buffer 8 bits per pixels
*/
for (k = 8; k--; d >>= 4)
if (d & 0x0F)
f[k] = (f[k] & 0xF0) | ((U8) d & 0x0F);
f += 8;
}
fb += 320;
}
}
/*
* Draw a sprite
*
* NOTE re-using original ST graphics format
*/
void draw_sprite2 (U8 number, U16 x, U16 y, U8 front)
{
U32 d = 0; /* sprite data */
S16 x0, y0; /* clipped x, y */
U16 w, h; /* width, height */
S16 g, /* sprite data offset*/
r, c, /* row, column */
i, /* frame buffer shifter */
im; /* tile flag shifter */
U8 flg; /* tile flag */
x0 = x;
y0 = y;
w = 0x20;
h = 0x15;
if (draw_clipms (&x0, &y0, &w, &h)) /* return if not visible */
return;
g = 0;
draw_setfb (x0 - DRAW_XYMAP_SCRLEFT, y0 - DRAW_XYMAP_SCRTOP);
for (r = 0; r < 0x15; r++)
{
if (r >= h || y + r < y0)
continue;
i = 0x1f;
im = x - (x & 0xfff8);
flg = map_eflg[map_map[(y + r) >> 3][(x + 0x1f)>> 3]];
#define LOOP(N, C0, C1) \
d = sprites_data[number][g + N]; \
\
for (c = C0; c >= C1; c--, i--, d >>= 4, im--) \
{ \
if (im == 0) \
{ \
flg = map_eflg[map_map[(y + r) >> 3][(x + c) >> 3]]; \
im = 8; \
} \
\
if (!front && (flg & MAP_EFLG_FGND)) \
continue; \
if (c >= w || x + c < x0) \
continue; \
if (d & 0x0F) \
fb[i] = (fb[i] & 0xF0) | ((U8) d & 0x0F); \
}
LOOP(3, 0x1f, 0x18);
LOOP(2, 0x17, 0x10);
LOOP(1, 0x0f, 0x08);
LOOP(0, 0x07, 0x00);
#undef LOOP
fb += 320;
g += 4;
}
}
/*
* Redraw the map behind a sprite
* align to tile column and row, and clip
*
* x, y: sprite position (pixels, map).
*/
void draw_spriteBackground (U16 x, U16 y)
{
U8 r, c;
U16 rmax, cmax;
S16 xmap, ymap;
U16 xs, ys;
/* aligne to column and row, prepare map coordinate, and clip */
xmap = x & 0xFFF8;
ymap = y & 0xFFF8;
cmax = (x - xmap == 0 ? 0x20 : 0x28); /* width, 4 tl cols, 8 pix each */
rmax = (y & 0x04) ? 0x20 : 0x18; /* height, 3 or 4 tile rows */
if (draw_clipms (&xmap, &ymap, &cmax, &rmax)) /* don't draw if fully clipped */
return;
/* get back to screen */
xs = xmap - DRAW_XYMAP_SCRLEFT;
ys = ymap - DRAW_XYMAP_SCRTOP;
xmap >>= 3;
ymap >>= 3;
cmax >>= 3;
rmax >>= 3;
/* draw */
for (r = 0; r < rmax; r++)
{
/* for each row */
draw_setfb (xs, ys + r * 8);
for (c = 0; c < cmax; c++)
draw_tile (map_map[ymap + r][xmap + c]); // for each column
}
}
/*
* Draw entire map screen background tiles onto frame buffer.
*
* ASM 0af5, 0a54
*/
void draw_map (void)
{
U8 i, j;
draw_tilesBank = map_tilesBank;
for (i = 0; i < 0x18; i++)
{
/* 0x18 rows */
draw_setfb (0x20, i * 8);
for (j = 0; j < 0x20; j++)
draw_tile (map_map[i + 8][j]); // 0x20 tiles per row
}
}
/*
* Draw status indicators
*
* ASM 0309
*/
void draw_drawStatus (void)
{
S8 i;
U32 sv;
static U8 s[7] = {0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfe};
draw_tilesBank = 0;
for (i = 5, sv = game_score; i >= 0; i--)
{
s[i] = 0x30 + (U8) (sv % 10);
sv /= 10;
}
draw_tllst = s;
draw_setfb (DRAW_STATUS_SCORE_X, DRAW_STATUS_Y);
draw_tilesList ();
draw_tilesBank = 0;
draw_setfb (DRAW_STATUS_BULLETS_X, DRAW_STATUS_Y);
for (i = 0; i < game_bullets; i++)
draw_tile (TILES_BULLET);
draw_tilesBank = map_tilesBank;
for (; i < 6; i++)
draw_tile (map_map[DRAW_STATUS_Y / 8 + 8][DRAW_STATUS_BULLETS_X / 8 + i - 4]);
draw_tilesBank = 0;
draw_setfb (DRAW_STATUS_BOMBS_X, DRAW_STATUS_Y);
for (i = 0; i < game_bombs; i++)
draw_tile (TILES_BOMB);
draw_tilesBank = map_tilesBank;
for (; i < 6; i++)
draw_tile (map_map[DRAW_STATUS_Y / 8 + 8][DRAW_STATUS_BOMBS_X / 8 + i - 4]);
draw_tilesBank = 0;
draw_setfb (DRAW_STATUS_LIVES_X, DRAW_STATUS_Y);
for (i = 0; i < game_lives; i++)
draw_tile (TILES_RICK);
draw_tilesBank = map_tilesBank;
for (; i < 6; i++)
draw_tile (map_map[DRAW_STATUS_Y / 8 + 8][DRAW_STATUS_LIVES_X / 8 + i - 4]);
}
/*
* Draw a picture
*/
void draw_pic (U16 x, U16 y, U16 w, U16 h, U32 *pic)
{
U8 *f;
U16 i, j, k, pp;
U32 v;
draw_setfb (x, y);
pp = 0;
for (i = 0; i < h; i++)
{
/* rows */
f = fb;
for (j = 0; j < w; j += 8)
{
/* cols */
v = pic[pp++];
for (k = 8; k--; v >>=4)
f[k] = (U8) v & 0x0F;
f += 8;
}
fb += 320;
}
}