Листинг 5.16. Tombstone (TOMB.С).

// ВКЛЮЧАЕМЫЕ ФАЙЛЫ /////////////////////////////////////////////

#include < io.h>

#include < conio.h>

#include < stdio.h>

#include < stdlib.h>

#include < dos.h>

#include < bios.h>

#include < fcntl.h>

#include < memory.h>

#include < math.h>

#include < string.h>

// ОПРЕДЕЛЕНИЯ //////////////////////////////////////////////////

#define ROM_CHAR_SET_SEG 0xF000 // сегмент описания символов в ПЗУ

#define ROM_CHAR_SET_OFF 0xFA6E // смещение, соответствующее

// описанию первого символа

#define VGA256 0х13

#define TEXT_MODE 0х03

#define PALETTE_MASK ОхЗC6

#define PALETTE_REGISTER_RD 0x3C7

#define PALETTE_REGISTER_WR 0x3C8

#define PALETTE_DATA 0x3C9

#define SCREEN_WIDTH (unsigned int)320

#define SCREEN_HEIGHT (unsigned int)200

#define CHAR_WIDTH 8

#define CHAR_HEIGHT 8

#define SPRITE_MIDTH 24

#define SPRITE_HEIGHT 24

#define MAX_SPRITE_FRAMES 16

#define SPRITE_DEAD 0

#define sprite_alive 1

#define SPRITE_DYING 2

// СТРУКТУРЫ ДАННЫХ ////////////////////////////////////////

typedef struct RGB_color_typ

{

unsigned char red; // красная составляющая цвета (0-63)

unsigned char green; // зеленая составляющая цвета (0-63)

unsigned char blue; // синяя составляющая цвета (0-63)

} RGB_color, *RGB_color_ptr;

typedef struct pcx_header_typ

{ char manufacturer;

char version;

char encoding;

char bits_per_pixel;

int x, y;

int width, height;

int horz_res;

int vert_res;

char ega_palette[46];

char reserved;

char num_color_planes;

int bytes_per_line;

int palette_type;

char padding[58];

} pcx_header, *pcx_header_ptr;

typedef struct pcx_picture_typ

{

pcx_header header;

RGB_color palette[256];

char far *buffer;

} pcx_picture, *pcx_picture_ptr;

typedef struct sprite_typ

{

int x, y; // текущая позиция спрайта

int x_old, y_old; // предыдущая позиция спрайта

int width, height; // размеры спрайта

int anim_clock; // время анимации

int anim_speed; // скорость анимации

int motion_speed; // скорость движения

int motion_clock; // время движения

char far *frames[MAX_SPRITE__FRAMES]; // массив указателей

// на образы

int curr_frame; // отображаемый фрейм

int num_frames; // общее число фреймов

int state; // статус спрайта

char far *background; // фон под спрайтом

}sprite, *sprite_ptr;

// ВНЕШНИЕ ФУНКЦИИ /////////////////////////////////

extern Set_Mode(int mode);

// ПРОТОТИПЫ ///////////////////////////////////////

void Set_Palette_Register(int index, RGB_color_ptr color);

void Plot_Pixel_Fast(int x, int y, unsigned char color);

void PCX_Init(pcx_picture *image);

void PCX_Delete(pcx_picture *image);

void PCX_Load(char *filename, pcx_picture_ptr image, int enable_palette);

void PCX_Show_Buffer(pcx_picture_ptr image);

// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ //////////////////////////////

unsigned char far *video_buffer = (char far *) 0xA0000000L;

unsigned int far *video_buffer_w = (int far *)0xA0000000L;

unsigned char far *rom_char_set = (char far *)0xF000FA6EL;

// ФУНКЦИИ ////////////////////////////////////////////

void Blit_Char(int xc, int yc, char c, int color) {

// эта функция отображает символ на экране

// используя описание

// символов размером 8х8 точек, хранящееся в ПЗУ

int offset, х, у;

unsigned char data;

char far *work_char;

unsigned char bit_mask = 0х80;

// вычисляем смещение описания символа в ПЗУ

work_char = rom_charset + с * CHAR_HEIGHT;

// вычисляем смещение символа в видеобуфере

offset = (ус < < 8} + (ус < < 6) + хс;

for (у=0; y< CHAR_HEIGHT; y++)

{

// сбросить битовую маску

bit_mask = 0х80;

for (x=0; x< CHAR_WIDTH; x++)

{ // если бит равен 1, рисуем пиксель

if ((*work_char & bit_mask))

video_buffer[offset+x] = color;

// сдвигаем маску

bit_mask = (bit_mask> > 1);

} // конец отрисовки строки

// переходим к следующей строке

offset += SCREEN_WIDTH;

work_char++;

} // конец рисования

} // конец функции

//////////////////////////////////////////////////////////

void Blit_String(int x, int y, int color, char *string)

{ // функция отображает на экране передаваемую строку символов

// Расстояние между символами строки постоянно

// Для отображения символов вызывается функция blit_char

int index;

for (index=0; string[index]! =0; index++)

{

Blit_Char(x+(index< < 3), y, string[index], color);

} // конец цикла for

} // конец функции

///////////////////////////////////////////////////////

void Delay(int t)

{

float x = 1;

while(t—> 0)

x=cos(x);

} // конец функции

///////////////////////////////////////////////////////

void Set_Palette_Register(int index, RGB_color_ptr color) {

// функция устанавливает элемент таблицы цветов задаваемый

// параметром index. Значения компонент цвета задаются полями

// структуры color.

// указываем VGA-карте, что мы будем изменять регистр палитры

_outp(PALETTE_MASK, Oxff);

// указываем номер изменяемого регистра

_outp(PALETTE_REGISTER_WR, index);

// теперь меняем значения компонентов. Каждый раз используется

// один и тот же порт

_outp(PALETTE_DATA, color-> red);

_outp(PALETTE_DATA, color-> green);

_outp(PALETTE_DATA, color-> blue);

} // конец функции

///////////////////////////////////////////////////////

void PCX_Init(pcx_picture_ptr image)

{

// функция выделяет память для загрузки PCX-файла

if ((image-> buffer = (char far *)malloc (SCREEN_WIDTH * SCREEN_HEIGHT +1)));

printf(" \ncouldn't allocate screen buffer");

} // конец функции

///////////////////////////////////////////////////////

void Plot_Pixel_Fast(int x, int y, unsigned char color)

{

// функция отображает на экране точку заданного цвета

// вместо умножения используется сдвиг

// пользуемся тем, что 320*у=256*у+64*у=у< < 8+у< < 6

video_buffer[ ((у< < 8) + (у< < 6)) + х] = color;

} // конец функции ///////////////////////////////////////////////////////////////////////////

void PCX_Delete(pcx_picture_ptr image)

{ // функция освобождает память, выделенную для загрузки PCX-файла

_ffree (image-> buffer);

} // конец функции

//////////////////////////////////////////////////////////

void PCX_Load(char *filename, pcx_picture_ptr image, int enable_palette}

{ // функция загружает PCX-файл и заполняет поля структуры

// pcx_picture, включая изображение (после декомпрессии),

// заголовок и палитру

FILE *fp;

int num_bytes, index;

long count;

unsigned char data;

char far *temp_buffer;

// открыть файл

fp = fopen(filename, " rb");

// загрузить заголовок

temp_buffer = (char far *)image;

for (index=0; index< 128; index++)

{

temp_buffer[index] = getc(fp);

} // конец цикла for

// загрузить данные и декодировать их в буфере

count=0;

while(count< =SCREEN_WIDTH * SCREEN_HEIGHT)

{ // получить первую часть данных

data = getc(fp);

// это RLE?

if (data> =192 & & data< =255)

{ // сколько байт сжато?

num_bytes = data-192;

// получить значение цвета для сжатых данных

data = getc(fp);

// заполняем буфер полученным цветом

while(num_bytes--> 0)

{

image-> buffer[count++] = data;

} // конец цикла while

} // конец обработки сжатых данных

else

{

// поместить значение цвета в очередную позицию

image-> buffer[count++] = data;

} // конец обработки несжатых данных

} // конец цикла while

// перейти в позицию, не доходя 768 байт от конца файла

fseek(fp, -768L, SEEK_END);

// загрузить палигру

for (index=0; index< 256; index++)

{

// красная составляющая

image-> palette[index].red = (getc(fp) > > 2);

// зеленая составляющая

image-> palette[index].green = (getc(fp) > > 2);

// синяя составляющая

image-> palette[index].blue = (getc(fp) > > 2);

} // конец цикла for

fclose(fp);

// если установлен флаг enable_palette, установить новую палитру

if (enable_palette)

{

for (index=0; index< 256; index++)

{

Set_Palette_Register(index,

(RGB_color_ptr)& image-> palette[index]);

} // конец цикла for

} // конец установки палитры

} // конец функции

//////////////////////////////////////////

void PCX_Show_Buffer (pcx_picture_ptr image)

{ // функция копирует буфер, содержащий изображение из PCX-файла,

// в видеопамять

_fmemcpy(char far *)video_buffer,

(char far *) image-> buffer, SCREEN_WIDTH*SCREEN__HEIGHT);

} // конец функции

////////////////////////////////////////////////////

void Sprite_Init(sprite_ptr sprite, int x, int y, int ac, int as, int mc, int ms)

{

// функция инициализирует спрайт

int index;

sprite-> x = x;

sprite-> y = у;

sprite-> x_old = x;

sprite-> y_old = у;

sprite-> width = SPRITE_WIDTH;

sprite-> height = SPRITE_HEIGHT;

sprite-> anim_clock = ac;

sprite-> anim_speed = as;

sprite-> motion_clock = me;

sprite-> motion_speed = ms;

sprite-> curr frame = 0;

sprite-> state = SPRITE_DEAD;

sprite-> num_frames = 0;

sprite-> background = (char far *)malloc (SPRITE_WIDTH * SPRITE_HEIGHT+1);

// устанавливаем все указатели в значение NULL

for (index=0; index< MAX_SPRITE_FRAMES; index++) sprite-> frames[index] = NULL;

} // конец функции

////////////////////////////////////////////////////////

void Sprite_Delete(sprite_ptr sprite)

{ // функция освобождает всю связанную со спрайтом память

int index;

_ffree(sprite-> background);

// освобождаем память, выделенную под кадры анимации

for (index=0; index< MAX_SPRITE_FRAMES; index++) _ffree(sprite-> frames(index]);

} // конец функции

///////////////////////////////////////////////////////

void PCX_Grap_Bitmap (pcx_picture_ptr image, sprite_ptr sprite, int sprite_frame, int grab_x, int grab_y)

{

// функция выделяет один кадр из буфера PCX-файла.

// Предполагается, что изображение размером 320х200 пикселей

// в действительности представляет собой массив 12х8 изображений

// каждое размерностью по 24х24 пикселя

int x_off, y_off, x, y, index;

char far *sprite_data;

//вначале выделяем память для размещения спрайта

sprite-> frames[sprite_frame] = (char far *)malloc (SPRITE_WIDTH * SPRITE_HEIGHT);

// создаем альтернативный указатель для ускорения доступа

sprite_data = sprite-> frames[sprite_frame];

// загружаем битовый образ в выделенную область памяти

// вначале вычисляем, какое из изображений копировать.

// Помните: в действительности PCX-файл представляет собой массив

// из отдельных элементов размером 24х24 пикселя.

// Индекс (0, 0) соответствует левому верхнему изображению,

// (11, 7) - правому нижнему.

x_off = 25 * grab_x + 1;

y_off = 25 * grab_y + 1;

// вычисляем начальный адрес

y_off = y_off * 320;

for (y=0; y< SPRITE__HEIGHT; y++)

{

for (x=0; x< SPRITE_WrETH; x++)

{

// берем очередной байт и помещаем его в текущую позицию буфера

sprite_data[y*24 + х] = image-> buffer [y_off + х_off + х];

} // конец копирования строки

// переходим к следующей строке y_off+=320;

} // конец копирования

// увеличиваем счетчик кадров sprite-> num_frames++;

} // конец функции

//////////////////////////////////////

void Behind_Sprite(sprite_ptr sprite)

{

// функция сохраняет содержимое видеопамяти в той области,

// куда будет выведен спрайта

char far *work back;

int work_offset=0, offset, y;

// создаем альтернативный указатель для ускорения доступа

work_back = sprite-> background;

// вычисляем смещение в видеопамяти

offset = (sprite-> y < < 6) + (sprite-> y < < 6) + sprite-> x;

for (y=0; y< SPRITE_HEIGHT; y++)

{

// копируем очередную строку видеопамяти в буфер

_fmemcpy((char far *)& work_back[work_offset], (char far *)& video_buffer[offset], SPRITE_WIDTH);

// переходим к следующей строке

offset += SCREEN_WIDTH;

work_offset += SPRITE_WIDTH;

} // конец цикла for

} // конец функции

///////////////////////////////////////////

void Erase_Sprite(sprite_ptr sprite)

{ // функция восстанавливает фон, сохраненный перед выводом спрайта

char far *work_back;

int work_offset=0, offset, y;

// создаем альтернативный указатель для ускорения доступа

work_back = sprite-> background;

// вычисляем смещение в видеобуфере

offset = (sprite-> y_old < < 8) + (sprite-> y_old < < 6} + sprite-> x_old;

for (y=0; y< SPRITE_HEIGHT; y++)

{

// копируем в видеопамять очередную строку буфера

_fmemcpy((char far *)& video_buffer [offset], (char far *)& work_back[work_offset], SPRITE_WIDTH);

// перейти к следующей строке

offset += SCREEN_WIDTH;

work_offset += SPRITE_WIDTH;

} // конец цикла for

} // конец функции

///////////////////////////////////////////////////////

void Draw_Sprite(sprite_ptr sprite)

{

// функция, рисующая спрайт на экране вместо умножения

// используется сдвиг

char far *work sprite;

int work_offset=0, offset, x, y;

unsigned char data;

work sprite = sprite-> frames[sprite-> curr_frame];

// вычислить смещение спрайта в видеобуфере

offset = (sprite-> y < < 8) + (sprite-> y < < 6) + sprite-> x;

for (y=0; y< SPRITE_HEIGHT; y++)

{

for (x=0; X< SPRITE_WIDTH; X++)

{

// проверяем, не является ли пиксель " прозрачным" (с кодом 0),

// если нет - рисуем

if ((data=work_sprite[work_offset+x]))

video_buffer[offset+x] = data;

} // конец вывода строки

// перейти к следующей строке в видеобуфере и буфере спрайта

offset += SCREEN_WIDTH;

work_offset += SPRITE_WIDTH;

} //конец цикла no Y

} // конец функции

// ОСНОВНАЯ ПРОГРАММА /////////////////////////////////////////

void main(void)

{

long index, redraw;

RGB_color color;

int frame_dir = 1;

pcx_picture town, cowboys;

sprite cowboy;

// установить видеорежим 320х200х256

Set_Mode(VGA256);

// установить глобальные указатели на область памяти экрана

Set_Screen_Pointers();

// загрузить фон

PCX_Init((pcx_picture_ptr)& town);

PCX_Load(" town. pox", (pcx_picture_ptr)& town, 1);

PCX_Show_Buffer((pcx_picture_ptr)& town);

PCX_Delete((pcx_picture_ptr)& town);

// вывести на экран заставку игры

Blit_String(128, 24, 50, " TOMBSTONE");

// загрузить образы

PCX_Init((pcx_picture_ptr)& cowboys);

PCX_Load(" cowboys.pcx", (pcx_picture_ptr) & cowboys, 0);

// извлечь все образы из PCX-файла

Sprite_Init((sprite_ptr)& cowboy, SPRITE_WIDTH, 100, 0, 7, 0, 3);

PCX_Grap_Bitmap ((pcx_picture_ptr) & cowboys, (sprite_ptr) & cowboy, 0, 0, 0);

PCX Grap_Bitmap((pcx_picture_ptr) & cowboys,

(sprite_ptr)& cowboy, 1, 1, 0);

PCX_Grap_Bitmap((pcx_picture_ptr)& cowboys,

(sprite_ptr)& cowboy, 2, 2, 0);

PCX_Grap_Bitmap ((pcx_picture_ptr)& cowboys,

(sprite_ptr)& cowboy, 3, 1, 0);

// очистить память, выделенную для загрузки PCX-файла PCX_Delete((pcx_picture_ptr)& cowboys);

Behind_Sprite((sprite_ptr)& cowboy);

Draw_Sprite ((sprite_ptr) & cowboy);

// главный цикл

cowboy.state = SPRITE_ALIVE;

while (! kbhit()) {

redraw = 0; // используется как флаг необходимости перерисовки

if (cowboy.state==SPRITE_ALIVE)

{

//не пора ли менять кадр?

if (++cowboy.anim_clock > cowboy.anim_speed)

{

// сбрасываем счетчик времени

cowboy.anim_clock = 0;

if (++cowboy.curr_frame > = cowboy. num_frames)

{

cowboy.curr_frame = 0;

} // конец обработки достижения последнего кадра

redraw=1;

} // конец смены кадра

// проверяем не пора ли передвигать спрайт

if (++cowboy.motion_clock > cowboy.motion_speed)

{

// переустановить счетчик движения

cowboy.motion clock =0;

// сохранить старую позицию

cowboy.x_old == cowboy.x;

redraw =1;

//передвинуть спрайт

if (++cowboy.x > = SCREEN_WIDTH-2*SPRITE_WIDTH)

{

Erase_Sprite((sprite_ptr)& cowboy);

cowboy.state = SPRITE_DEAD;

redraw = 0;

} // конец обработки достижения последнего кадра

} // конец обработки движения спрайта

} // конец обработки ситуации " ковбой жив"

else

{ // пытаемся " оживить" ковбоя

if (rand()%100 == 0)

{

cowboy.state = SPRITE_ALIVE;

cowboy.x = SPRITE_WIDTH;

cowboy.curr frame = 0;

cowboy.anim.speed = 3 + rand()%6;

cowboy.motion_speed = 1 + rand()%3;

cowboy.anim_clock = 0;

cowboy.motion_clock = 0;

Behind_Sprite{(sprite_ptr)& cowboy);

}

} // конец процесса " оживления"

// теперь состояние спрайта изменено

if (redraw)

{

// удалить спрайт в старой позиции

Erase_Sprite((sprite_ptr)& cowboy);

// сохранить фон в новой позиции

Behind_Sprite((sprite_ptr)& cowboy);

// нарисовать спрайт в новой позиции

Draw_Sprite((sprite_ptr)& cowboy);

// обновить старые координаты

cowboy.x_old = cowboy.x;

cowboy.у_old = cowboy.у;

} // конец перерисовки

Delay(1000);

} // конец главного игрового цикла

for(index=0; index < 300000; index++, Plot_Pixel_Fast(rand()%320,

rand()%200, 0));

//Перейти обратно в текстовый режим

Set_Mode(TEXT_MODE);

}//Конец функции main

Итог

Эта глава, наверное, самая важная в книге. Среди всей информации, которая, может быть, не относится напрямую к играм, вы узнали общую концепцию построения видеоигр, что абсолютно необходимо для их написания. Так что, если вы чего-то не поняли, то остановитесь и прочтите главу вновь (не беспокойтесь, я вас подожду).

Если вы прочитали и поняли в этой главе все, то.должны знать, что:

§ Мы изучили VGA-карту и ее архитектуру;

§ Мы узнали о режиме l3h, который дает лучшее разрешение и наиболее прост для программирования;

§ Мы узнали, как в режиме l3h программировать регистры цвета, рисовать пиксели, загружать PCX-файлы и перемещать битовые образы;

§ Мы поговорили о спрайтах и создали простую библиотеку для работы с ними;

§ Мы затронули довольно сложные вещи, такие как дублирующий буфер и

§ вертикальная синхронизация, о которых более подробно мы поговорим чуть позже;

§ И, наконец, собрав все вместе, мы сделали демонстрационную программу, рисующую маленького ковбоя, который ходит по городу.

До встречи в новой главе.