sonback.c

自制 校园坦克 游戏 C实现 比较简单 代码全

#include <io.h>
#include <bios.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <bios.h>
#include <fcntl.h>
#include <mem.h>
#include <math.h>
#include <string.h>
#include <malloc.h>
#include <time.h>

#define TANK_SPEED 4
#define PI (float)3.14159

#define sprite_SPEED 4

#define SPRITE_DEAD 0
#define SPRITE_ALIVE 1
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 40
#define SCREEN_WIDTH1 320
#define SCREEN_HEIGHT1 200

#define VGA256 0x13
#define TEXT_MODE 0x03


#define SPRITE_WIDTH 16
#define SPRITE_HEIGHT 16

#define MAX_SPRITE_FRAMES 8

#define PALETTE_MASK 0x3c6
#define PALETTE_REGISTER_RD 0x3c7
#define PALETTE_REGISTER_WR 0x3c8
#define PALETTE_DATA 0x3c9
typedef struct RGB_color_typ
{
unsigned char red;
unsigned char green;
unsigned char blue;
}RGB_color,*RGB_color_ptr;


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

void Delay(int clicks)
{
unsigned int far *clock=(unsigned int far *)0x0000046CL;
unsigned int now;
now=*clock;
while(abs(*clock-now)<clicks){}
}


void Set_Video_Mode(int mode)
{
	union REGS inregs,outregs;
	inregs.h.ah=0;
	inregs.h.al=(unsigned char)mode;
	int86(0x10,&inregs,&outregs);
}


void Set_Palette_Register(int index,RGB_color_ptr color)
{
outp(PALETTE_MASK,0xff);
outp(PALETTE_REGISTER_WR,index);
outp(PALETTE_DATA,color->red);
outp(PALETTE_DATA,color->green);
outp(PALETTE_DATA,color->blue);
}

void Plot_Pixel_Fast(int x,int y,char color)
{
video_buffer[((y<<8)+(y<<6))+x]=color;
}

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[48];
	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;


void PCX_Init(pcx_picture_ptr image)
{
unsigned int a=(unsigned int)(SCREEN_WIDTH * SCREEN_HEIGHT + 1);
// this function allocates the buffer region needed to load a pcx file
if((image->buffer = (char far *)malloc(a))==NULL)
{
   printf("\ncouldn't allocate screen buffer");
 exit(1);
 }
} // end PCX_Init

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


void PCX_Delete(pcx_picture_ptr image)
{
// this function de-allocates the buffer region used for the pcx file load

free(image->buffer);

} // end PCX_Delete

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

void PCX_Load(char *filename, pcx_picture_ptr image,int enable_palette)
{
// this function loads a pcx file into a picture structure, the actual image
// data for the pcx file is decompressed and expanded into a secondary buffer
// within the picture structure, the separate images can be grabbed from this
// buffer later.  also the header and palette are loaded

FILE *fp;
int num_bytes,index;
unsigned int count;
unsigned char data;
char far *temp_buffer;

// open the file

fp = fopen(filename,"rb");

// load the header

temp_buffer = (char far *)image;

for (index=0; index<128; index++)
    {
    temp_buffer[index] = getc(fp);
    } // end for index

// load the data and decompress into buffer
count=0;


while(count<=(unsigned int)SCREEN_WIDTH * SCREEN_HEIGHT)
	 {
	 // get the first piece of data

	 data = getc(fp);

	 // is this a rle?

     if (data>=192 && data<=255)
	{
        // how many bytes in run?

        num_bytes = data-192;

	// get the actual data for the run

	data  = getc(fp);

		// replicate data in buffer num_bytes times

        while(num_bytes-->0)
             {
             image->buffer[count++] = data;

             } // end while

        } // end if rle
     else
	{
        // actual data, just copy it into buffer at next location

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

        } // end else not rle

     } // end while

// move to end of file then back up 768 bytes i.e. to begining of palette

fseek(fp,-768L,SEEK_END);

// load the pallete into the palette

for (index=0; index<256; index++)
    {
    // get the red component

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

    // get the green component

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

    // get the blue component

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

    } // end for index

fclose(fp);

// change the palette to newly loaded palette if commanded to do so

if (enable_palette)
   {

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

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

       } // end for index

   } // end if change palette

} // end PCX_Load

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


void PCX_Load_Screen(char *filename,int enable_palette)
{
// this function loads a pcx file into a picture structure, the actual image
// data for the pcx file is decompressed and expanded into a secondary buffer
// within the picture structure, the separate images can be grabbed from this
// buffer later.  also the header and palette are loaded

FILE *fp;
int num_bytes,index;
unsigned int count;
unsigned char data;
RGB_color palette[256];
// open the file


fp = fopen(filename,"rb");


fseek(fp,128L,SEEK_SET);
// load the data and decompress into buffer
count=0;


while(count<=(unsigned int)SCREEN_WIDTH * SCREEN_HEIGHT1)
	 {
	 // get the first piece of data

	 data = getc(fp);

	 // is this a rle?

     if (data>=192 && data<=255)
	{
	// how many bytes in run?

        num_bytes = data-192;

	// get the actual data for the run

	data  = getc(fp);

		// replicate data in buffer num_bytes times

        while(num_bytes-->0)
	     {
//             image->buffer[count++] = data;
  video_buffer[count++]=data;
	     } // end while

	} // end if rle
     else
	{
	// actual data, just copy it into buffer at next location

	//image->buffer[count++] = data;
	  video_buffer[count++]=data;
	} // end else not rle

     } // end while
for (index=0; index<256; index++)
    {
    // get the red component

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

    // get the green component

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

    // get the blue component

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

    } // end for index

fclose(fp);

// change the palette to newly loaded palette if commanded to do so

if (enable_palette)
   {

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

       Set_Palette_Register(index,(RGB_color_ptr)&palette[index]);

       } // end for index

   } // end if change palette

} // end PCX_Load


typedef struct key
{
char up;
char down;
char left;
char right;
char stop;
char quit;
char fight;
}key,key_ptr;

typedef struct sprite_type
{
int x,y;
int x_old,y_old;
int width,height;
int anim_clock;
int anim_speed;
int motion_clock;
int motion_speed;
char far *frames[MAX_SPRITE_FRAMES];
int curr_frame;
int num_frames;
int state;
char far *background;
void far *extra_data;
struct sprite_type *next;
void (far *spr)(struct sprite_type *spr);
key key;
}sprite,*sprite_ptr;

sprite_ptr head,now,pre;
char get_key;

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

{
// this function will grap a bitmap from the pcx frame buffer. it uses the
// convention that the 320x200 pixel matrix is sub divided into a smaller
// matrix of 12x8 adjacent squares each being a 24x24 pixel bitmap
// the caller sends the pcx picture along with the sprite to save the image
// into and the frame of the sprite.  finally, the position of the bitmap
// that should be grabbed is sent

int x_off,y_off, x,y, index;
char far *sprite_data;

// first allocate the memory for the sprite in the sprite structure

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

// create an alias to the sprite frame for ease of access

sprite_data = sprite->frames[sprite_frame];