outofmouth.cpp

考验你的观察力和判断力的时候到了

// outofmouth demo 8-bit blitting

// INCLUDES ///////////////////////////////////////////////

#define WIN32_LEAN_AND_MEAN  // 无 MFC

#define INITGUID

#include <windows.h>   // include important windows stuff
#include <windowsx.h> 
#include <mmsystem.h>
#include <iostream> // include important C/C++ stuff
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h> 
#include <math.h>
#include <io.h>
#include <fcntl.h>

#include <ddraw.h> // include directdraw

// DEFINES ////////////////////////////////////////////////

// defines for windows 
#define WINDOW_CLASS_NAME "WINCLASS1"

// default screen size
#define SCREEN_WIDTH    1024  // size of screen
#define SCREEN_HEIGHT   768
#define SCREEN_BPP      8    // bits per pixel

#define BITMAP_ID            0x4D42 // universal id for a bitmap
#define MAX_COLORS_PALETTE   256

///defines for game 
#define BOW_WIDTH         42       //爆炸宽
#define BOW_HEIGHT        36       ///爆炸高
#define ALL_BOW           14

#define BOW2_WIDTH        86       //爆炸宽
#define BOW2_HEIGHT       74       ///爆炸高
#define ALL_BOW2          14

#define TOOTH_WIDTH       50       //牙齿宽
#define TOOTH_HEIGHT      150      //牙齿高

#define SMALLONE_WIDTH    50       //小东西宽
#define SMALLONE_HEIGHT   30       //小东西高

#define INIT_BOTTOM_X     300      //底部第一个牙齿X坐标
#define INIT_BOTTOM_y     450      //底部第一个牙齿Y坐标

#define DISTANCE          200      //底部牙齿与上部的距离

#define TOOTH_NUM         7        //一排牙齿的数目

#define SHAPE_NUM         5        //单排牙齿形状数
#define ALL_SHAPE_NUM     10       //上下牙齿形状数

#define INIT_SPEED        1        //游戏速度，牙齿速度，33pixel/sec

#define SMALLONE_INIT_y   560
#define SMALLONE_SPEC     110 

#define DELAY             8        //操作延迟时间 N frame

#define FRAME_PER_SEC     30       //frame per sec = 1sec/N(30)=33.3fps

#define DEATH_DELAY       30

// TYPES //////////////////////////////////////////////////////

// basic unsigned types
typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;

// container structure for bitmaps .BMP file
typedef struct BITMAP_FILE_TAG
        {
        BITMAPFILEHEADER bitmapfileheader;  // this contains the bitmapfile header
        BITMAPINFOHEADER bitmapinfoheader;  // this is all the info including the palette
        PALETTEENTRY     palette[256];      // we will store the palette here
        UCHAR            *buffer;           // this is a pointer to the data

        } BITMAP_FILE, *BITMAP_FILE_PTR;

// this will hold our little alien
typedef struct ALIEN_OBJ_TYP
        {
        LPDIRECTDRAWSURFACE7 frames[14]; // 3 frames of animation for complete walk cycle
        int x,y;                        // position of alien
        int velocity;                   // x-velocity
        int current_frame;              // current frame of animation
        int counter;                    // used to time animation
		int position;
 
        } ALIEN_OBJ, *ALIEN_OBJ_PTR;

//牙齿的关卡地图结构
typedef struct MAP_SET_TYP
{
	ALIEN_OBJ BottomSet[TOOTH_NUM];       //下排牙齿的数地图
	ALIEN_OBJ TopSet[TOOTH_NUM];          //下排牙齿的数地图
	int iKey;                             //缺牙地址
} MAP_SET, *MAP_SET_PTR;

// PROTOTYPES  //////////////////////////////////////////////

int Build_Map();

int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height);

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename);

int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap);

int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE7 lpdds,int color);

int Scan_Image_Bitmap(BITMAP_FILE_PTR bitmap, LPDIRECTDRAWSURFACE7 lpdds, int cx,int cy);

LPDIRECTDRAWSURFACE7 DDraw_Create_Surface(int width, int height, int mem_flags, int color_key);

int DDraw_Draw_Surface(LPDIRECTDRAWSURFACE7 source, int x, int y, 
                      int width, int height, LPDIRECTDRAWSURFACE7 dest, 
                      int transparent);    

LPDIRECTDRAWCLIPPER DDraw_Attach_Clipper(LPDIRECTDRAWSURFACE7 lpdds,
                                         int num_rects,
                                         LPRECT clip_list);

int Draw_Text_GDI(char *text, int x,int y,COLORREF color, LPDIRECTDRAWSURFACE7 lpdds);

// MACROS /////////////////////////////////////////////////

// tests if a key is up or down
#define KEYDOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// initializes a direct draw struct
#define DDRAW_INIT_STRUCT(ddstruct) { memset(&ddstruct,0,sizeof(ddstruct)); ddstruct.dwSize=sizeof(ddstruct); }

// GLOBALS ////////////////////////////////////////////////

HWND      main_window_handle = NULL; // globally track main window
int       window_closed      = 0;    // tracks if window is closed
HINSTANCE hinstance_app      = NULL; // globally track hinstance

// directdraw stuff

LPDIRECTDRAW7         lpdd         = NULL;   // dd4 object
LPDIRECTDRAWSURFACE7  lpddsprimary = NULL;   // dd primary surface
LPDIRECTDRAWSURFACE7  lpddsback    = NULL;   // dd back surface
LPDIRECTDRAWPALETTE   lpddpal      = NULL;   // a pointer to the created dd palette
LPDIRECTDRAWCLIPPER   lpddclipper  = NULL;   // dd clipper
PALETTEENTRY          palette[256];          // color palette
PALETTEENTRY          save_palette[256];     // used to save palettes
DDSURFACEDESC2        ddsd;                  // a direct draw surface description struct
DDBLTFX               ddbltfx;               // used to fill
DDSCAPS2              ddscaps;               // a direct draw surface capabilities struct
HRESULT               ddrval;                // result back from dd calls
DWORD                 start_clock_count = 0; // used for timing
//全局结构体变量
BITMAP_FILE           bitmap;                // holds the bitmap

ALIEN_OBJ             aliens[3];             // 3 aliens, one on each level
ALIEN_OBJ             tooth[ALL_SHAPE_NUM];
ALIEN_OBJ             smallone;
ALIEN_OBJ             bow;
ALIEN_OBJ             bow2;

MAP_SET               map;                    //地图


LPDIRECTDRAWSURFACE7  lpddsbackground = NULL;// this will hold the background image

char buffer[600];                             // general printing buffer

int gwidth  = -1;
int gheight = -1;

//mine////////////////////////////////全局变量
int turnflag=0;
char *text=NULL;
char num[80];

int iFrame=0;

int iLevelNum=0;                  //过关数目

int iScore=0;                     //游戏分数
int iLevel=0;

int iSpeed=INIT_SPEED;            //游戏速度，牙齿速度，50pixel/sec

int iTimeCounter=0;               //操作延迟计数器
int delayflag=0;				  //操作延迟标志

int iCounterBow=0;                //爆炸精灵计数器
int iBowFlag=0;					
int iCounterBow2=0;
int iBowFlag2=0;

//game state
int iDistance=DISTANCE;		      //上下排牙齿距离
int iDeathFlag=0;				  //死亡标志

int iDeathTimeCounter=0;		  //死亡延迟
int iDeathDelayFlag=0;

int iGameMode=0;           //游戏模式0：记分模式，1：闯关模式，2：连续模式，3:极限模式


// FUNCTIONS ////////////////////////////////////////////////

int Build_Map()
{
	//生成地图
	srand(GetTickCount());
	map.iKey=rand()%(TOOTH_NUM);  //随机缺牙位置
	smallone.position=rand()%(TOOTH_NUM);//随机小东西位置
	srand(GetTickCount());
	for(int index=0; index<TOOTH_NUM; index++)
	{
		//分配下上部分地图
		if(index==map.iKey)
		{
			//缺牙
			map.BottomSet[index].current_frame=rand()%(SHAPE_NUM-1); //current_frame为该位置的位图编号
			map.TopSet[index].current_frame=((ALL_SHAPE_NUM - 2) - map.BottomSet[index].current_frame);
			//分配下部坐标
			map.BottomSet[index].x        = INIT_BOTTOM_X + index * TOOTH_WIDTH;
			map.BottomSet[index].y        = INIT_BOTTOM_y;
			map.BottomSet[index].velocity = iSpeed;
			map.BottomSet[index].counter  = 0;
			//分配上部坐标
			map.TopSet[index].x        = INIT_BOTTOM_X + index * TOOTH_WIDTH;
			map.TopSet[index].y        = INIT_BOTTOM_y - DISTANCE;
			map.TopSet[index].velocity = iSpeed;
			map.TopSet[index].counter  = 0;
		}
		else
		{
			//平牙
			map.BottomSet[index].current_frame=rand()%SHAPE_NUM; //current_frame为该位置的位图编号
			map.TopSet[index].current_frame=((ALL_SHAPE_NUM - 1) - map.BottomSet[index].current_frame);
			//分配下部坐标
			map.BottomSet[index].x        = INIT_BOTTOM_X + index * TOOTH_WIDTH;
			map.BottomSet[index].y        = INIT_BOTTOM_y;
			map.BottomSet[index].velocity = iSpeed;
			map.BottomSet[index].counter  = 0;
			//分配上部坐标
			map.TopSet[index].x        = INIT_BOTTOM_X + index * TOOTH_WIDTH;
			map.TopSet[index].y        = INIT_BOTTOM_y - DISTANCE;
			map.TopSet[index].velocity = iSpeed;
			map.TopSet[index].counter  = 0;
		}
	}
	for(index=1; index<TOOTH_NUM; index++)
	{
		//对齐
		map.BottomSet[index].x-=index;
		map.TopSet[index].x-=index;
	}
	//init smallone
	smallone.x              = ( INIT_BOTTOM_X + smallone.position * TOOTH_WIDTH );
    smallone.y              = SMALLONE_INIT_y - map.BottomSet[smallone.position].current_frame * 30;               
    smallone.velocity       = iSpeed;
    smallone.current_frame  = 0;             
    smallone.counter        = 0; 

	return(1);
}

int Load_Bitmap_File(BITMAP_FILE_PTR bitmap, char *filename)
{
// this function opens a bitmap file and loads the data into bitmap

int file_handle,  // the file handle
    index;        // looping index

UCHAR   *temp_buffer = NULL; // used to convert 24 bit images to 16 bit
OFSTRUCT file_data;          // the file data information

// open the file if it exists
if ((file_handle = OpenFile(filename,&file_data,OF_READ))==-1)
   return(0);

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapfileheader,sizeof(BITMAPFILEHEADER));

// test if this is a bitmap file
if (bitmap->bitmapfileheader.bfType!=BITMAP_ID)
   {
   // close the file
   _lclose(file_handle);

   // return error
   return(0);
   } // end if

// now we know this is a bitmap, so read in all the sections

// first the bitmap infoheader

// now load the bitmap file header
_lread(file_handle, &bitmap->bitmapinfoheader,sizeof(BITMAPINFOHEADER));

// now load the color palette if there is one
if (bitmap->bitmapinfoheader.biBitCount == 8)
   {
   _lread(file_handle, &bitmap->palette,MAX_COLORS_PALETTE*sizeof(PALETTEENTRY));

   // now set all the flags in the palette correctly and fix the reversed 
   // BGR RGBQUAD data format
   for (index=0; index < MAX_COLORS_PALETTE; index++)
       {
       // reverse the red and green fields
       int temp_color                = bitmap->palette[index].peRed;
       bitmap->palette[index].peRed  = bitmap->palette[index].peBlue;
       bitmap->palette[index].peBlue = temp_color;
       
       // always set the flags word to this
       bitmap->palette[index].peFlags = PC_NOCOLLAPSE;
       } // end for index

    } // end if

// finally the image data itself
_lseek(file_handle,-(int)(bitmap->bitmapinfoheader.biSizeImage),SEEK_END);

// now read in the image, if the image is 8 or 16 bit then simply read it
// but if its 24 bit then read it into a temporary area and then convert
// it to a 16 bit image

if (bitmap->bitmapinfoheader.biBitCount==8 || bitmap->bitmapinfoheader.biBitCount==16 || 
    bitmap->bitmapinfoheader.biBitCount==24)
   {
   // delete the last image if there was one
   if (bitmap->buffer)
       free(bitmap->buffer);

   // allocate the memory for the image
   if (!(bitmap->buffer = (UCHAR *)malloc(bitmap->bitmapinfoheader.biSizeImage)))
      {
      // close the file
      _lclose(file_handle);

      // return error
      return(0);
      } // end if

   // now read it in
   _lread(file_handle,bitmap->buffer,bitmap->bitmapinfoheader.biSizeImage);

   } // end if
else
   {
   // serious problem
   return(0);

   } // end else

#if 0
// write the file info out 
printf("\nfilename:%s \nsize=%d \nwidth=%d \nheight=%d \nbitsperpixel=%d \ncolors=%d \nimpcolors=%d",
        filename,
        bitmap->bitmapinfoheader.biSizeImage,
        bitmap->bitmapinfoheader.biWidth,
        bitmap->bitmapinfoheader.biHeight,
		bitmap->bitmapinfoheader.biBitCount,
        bitmap->bitmapinfoheader.biClrUsed,
        bitmap->bitmapinfoheader.biClrImportant);
#endif

// close the file
_lclose(file_handle);

// flip the bitmap
Flip_Bitmap(bitmap->buffer, 
            bitmap->bitmapinfoheader.biWidth*(bitmap->bitmapinfoheader.biBitCount/8), 
            bitmap->bitmapinfoheader.biHeight);

// return success
return(1);

} // end Load_Bitmap_File

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

int Unload_Bitmap_File(BITMAP_FILE_PTR bitmap)
{
// this function releases all memory associated with "bitmap"
if (bitmap->buffer)
   {
   // release memory
   free(bitmap->buffer);

   // reset pointer
   bitmap->buffer = NULL;

   } // end if

// return success
return(1);

} // end Unload_Bitmap_File

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

int Flip_Bitmap(UCHAR *image, int bytes_per_line, int height)
{
// this function is used to flip bottom-up .BMP images

UCHAR *buffer; // used to perform the image processing
int index;     // looping index

// allocate the temporary buffer
if (!(buffer = (UCHAR *)malloc(bytes_per_line*height)))
   return(0);

// copy image to work area
memcpy(buffer,image,bytes_per_line*height);

// flip vertically
for (index=0; index < height; index++)
    memcpy(&image[((height-1) - index)*bytes_per_line],
           &buffer[index*bytes_per_line], bytes_per_line);

// release the memory
free(buffer);