sonback.c

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

// now load the sprite data into the sprite frame array from the pcx picture

// we need to find which bitmap to scan, remember the pcx picture is really a
// 12x8 matrix of bitmaps where each bitmap is 24x24 pixels. note:0,0 is upper
// left bitmap and 11,7 is the lower right bitmap.

x_off = (SPRITE_WIDTH) * grab_x;
y_off = (SPRITE_HEIGHT) * grab_y ;

// compute starting y address

y_off = y_off * 320;

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

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

	// get the next byte of current row and place into next position in
	// sprite frame data buffer

	sprite_data[y*SPRITE_WIDTH + x] = image->buffer[y_off + x_off + x];

	} // end for x

	// move to next line of picture buffer

	y_off+=320;

    } // end for y

// increment number of frames

sprite->num_frames++;

// done!, let's bail!

} // end PCX_Grap_Bitmap


void Sprite_Init(sprite_ptr sprite,int x,int y,int ac,int as,int mc,int ms,void (far *spr),char key[7])
{
// this function initializes a sprite with the sent data

int index;

sprite->x            = x;
sprite->y            = y;
sprite->x_old        = x;
sprite->y_old        = y;
sprite->width        = SPRITE_WIDTH;
sprite->height       = SPRITE_HEIGHT;
sprite->anim_clock   = ac;
sprite->anim_speed   = as;
sprite->motion_clock = mc;
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);
sprite->spr=spr;
sprite->key.up=key[0];
sprite->key.down=key[1];
sprite->key.left=key[2];
sprite->key.right=key[3];
sprite->key.stop=key[4];
sprite->key.quit=key[5];
sprite->key.fight=key[6];
// set all bitmap pointers to null

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

} // end Sprite_Init

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

void Sprite_Delete(sprite_ptr sprite)
{
// this function deletes all the memory associated with a sprire

int index;

farfree(sprite->background);

// now de-allocate all the animation frames

for (index=0; index<MAX_SPRITE_FRAMES; index++)
    farfree(sprite->frames[index]);
free(sprite);
} // end Sprite_Delete

void Draw_Sprite(sprite_ptr sprite)
{

// this function draws a sprite on the screen row by row very quickly
// note the use of shifting to implement multplication

char far *work_sprite;
int work_offset=0,offset,x,y;
//unsigned char data;

// alias a pointer to sprite for ease of access

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

// compute offset of sprite in video buffer

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

for (y=0; y<SPRITE_HEIGHT; y++)
    {
    // copy the next row into the screen buffer using memcpy for speed

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

	// test for transparent pixel i.e. 0, if not transparent then draw
      if(work_sprite[work_offset+x])

	 //data==(unsigned char)work_sprite[work_offset+x];
// if(data)
//	     video_buffer[offset+x] =data;
     video_buffer[offset+x]=work_sprite[work_offset+x];
	} // end for x

    // move to next line in video buffer and in sprite bitmap buffer

    offset      += SCREEN_WIDTH;
    work_offset += SPRITE_WIDTH;

    } // end for y

} // end Draw_Sprite


void Behind_Sprite(sprite_ptr sprite)
{

// this function scans the background behind a sprite so that when the sprite
// is draw, the background isnn'y obliterated

char far *work_back;
int work_offset=0,offset,y;

// alias a pointer to sprite background for ease of access

work_back = sprite->background;

// compute offset of background in video buffer

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

for (y=0; y<SPRITE_HEIGHT; y++)
    {
    // copy the next row out off screen buffer into sprite background buffer

    _fmemmove((void far *)&work_back[work_offset],
	     (void far *)&video_buffer[offset],
	     SPRITE_WIDTH);

    // move to next line in video buffer and in sprite background buffer

    offset      += SCREEN_WIDTH;
    work_offset += SPRITE_WIDTH;

    } // end for y

} // end Behind_Sprite

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


void Erase_Sprite(sprite_ptr sprite)
{
// replace the background that was behind the sprite

// this function replaces the background that was saved from where a sprite
// was going to be placed

char far *work_back;
int work_offset=0,offset,y;

// alias a pointer to sprite background for ease of access

work_back = sprite->background;

// compute offset of background in video buffer

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

for (y=0; y<SPRITE_HEIGHT; y++)
    {
    // copy the next row out off screen buffer into sprite background buffer

    _fmemmove((void far *)&video_buffer[offset],
	     (void far *)&work_back[work_offset],
	     SPRITE_WIDTH);

    // move to next line in video buffer and in sprite background buffer

    offset      += SCREEN_WIDTH;
    work_offset += SPRITE_WIDTH;

    } // end for y


} // end Erase_Sprite


void Fill_Screen(int value)
{
_fmemset(video_buffer,(char)value,SCREEN_WIDTH*SCREEN_HEIGHT1+1);
}


void Clear_Key_Buffer(void)
{
int offset;
offset=peek(0x40,0x1a);
pokeb(0x40,0x1c,offset);
}

void Sheer(void)
{
long index;
int x,y;
x=rand()%320;
y=rand()%200;
for(index=0;index<100000;index++)
{
x+=17;
y+=13;
if(x>319)
x=x-319;
if(y>199)
y=y-199;
Plot_Pixel_Fast(x,y,0);
}
}

void spr(sprite_ptr sprite)
{
static int sprite_direction=0;
static float dx,dy,dxx=0,dyy=0,angle;
static int i,j=2,k,l=1;
char get_key;
l=-l;
k=0;

Erase_Sprite(sprite);

if(l==1)
{
if(kbhit())
{
get_key=getch();
Clear_Key_Buffer();
k=1;
dx=dy=0;

if(get_key==sprite->key.up)
{
sprite_direction=0;
angle=(90+360-360/(MAX_SPRITE_FRAMES/2)*(float)sprite_direction);
dxx=dx=sprite_SPEED*cos(PI*angle/180);
dyy=dy=sprite_SPEED*sin(PI*angle/180);
}
if(get_key==sprite->key.right)
{
sprite_direction=1;
angle=(90+360-360/(MAX_SPRITE_FRAMES/2)*(float)sprite_direction);
dxx=dx=sprite_SPEED*cos(PI*angle/180);
dyy=dy=sprite_SPEED*sin(PI*angle/180);
}
if(get_key==sprite->key.down)
{
sprite_direction=2;
angle=(90+360-360/(MAX_SPRITE_FRAMES/2)*(float)sprite_direction);
dxx=dx=sprite_SPEED*cos(PI*angle/180);
dyy=dy=sprite_SPEED*sin(PI*angle/180);
}
if(get_key==sprite->key.left)
{
sprite_direction=3;
angle=(90+360-360/(MAX_SPRITE_FRAMES/2)*(float)sprite_direction);
dxx=dx=sprite_SPEED*cos(PI*angle/180);
dyy=dy=sprite_SPEED*sin(PI*angle/180);
}

if(get_key==sprite->key.quit)
{
Sprite_Delete(sprite);

Sheer();
Set_Video_Mode(TEXT_MODE);
exit(1);
}

sprite->x+=(int)(dx+.5);
if(sprite->x>319-(int)SPRITE_WIDTH)
sprite->x=319-(int)SPRITE_WIDTH;
else if(sprite->x<0)
sprite->x=0;

sprite->y-=(int)(dy+.5);



if(sprite->y>199-(int)SPRITE_HEIGHT)
sprite->y=199-(int)SPRITE_HEIGHT;
else if(sprite->y<0)
sprite->y=0;
sprite->curr_frame=sprite_direction;
}

if(k==0)
if(get_key!=sprite->key.stop)
{
sprite->x+=(int)(dxx+.5);
if(sprite->x>319-(int)SPRITE_WIDTH)
sprite->x=319-(int)SPRITE_WIDTH;
else if(sprite->x<0)
sprite->x=0;

sprite->y-=(int)(dyy+.5);
if(sprite->y>199-(int)SPRITE_HEIGHT)
sprite->y=199-(int)SPRITE_HEIGHT;
else if(sprite->y<0)
sprite->y=0;
sprite->curr_frame=sprite_direction;

}
}

else
{
j=-j;
sprite->curr_frame=sprite_direction+2+j;
}


Behind_Sprite(sprite);

Draw_Sprite(sprite);

Delay(2);

}

void Judge_Sprite(void)
{
sprite_ptr sprite;
sprite=head;
do{
	sprite->spr(sprite);
	sprite=sprite->next;
}while(sprite!=NULL);
}


void main(void)
{
long index;
pcx_picture background_pcx,objects_pcx;
char key[7]={'8','2','4','6','5','q','0'};

Set_Video_Mode(VGA256);
PCX_Init((pcx_picture_ptr)&objects_pcx);

PCX_Load_Screen("poem.pcx",1);
PCX_Load("attank2.pcx",(pcx_picture_ptr)&objects_pcx,1);

now=pre=(struct sprite *)malloc(sizeof(struct sprite_type));
head=now;
Sprite_Init(now,0,0,0,0,0,0,spr,key);
pre->next=NULL;

for(index=0;index<MAX_SPRITE_FRAMES;index++)
{
 PCX_Grab_Bitmap((pcx_picture_ptr)&objects_pcx,now,index,index,0);
}

PCX_Delete((pcx_picture_ptr)&objects_pcx);


Behind_Sprite(now);

while(1){
	Judge_Sprite();
}
}