direct~2.cpp

一个简单的rpg游戏

#include "Headers.h"
#include "DirectDrawApp.h"
#include "DirectDrawWin.h"


#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

BEGIN_MESSAGE_MAP(DirectDrawWin, CWnd)
	//{{AFX_MSG_MAP(DirectDrawWin)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_MOUSEMOVE()
	ON_WM_ERASEBKGND()
	ON_WM_ACTIVATEAPP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


long DirectDrawWin::mousex;
long DirectDrawWin::mousey;
UINT DirectDrawWin::mousestate;
DirectDrawWin* DirectDrawWin::thisptr;


BOOL DirectDrawWin::ActivateDisplayMode( int mode, DWORD rate )
{
	if ( mode<0 || mode>=totaldisplaymodes )
		return FALSE;

	DWORD width = displaymode[mode].width;
	DWORD height = displaymode[mode].height;
	DWORD depth = displaymode[mode].depth;
	
	displayrect.left=0;
	displayrect.top=0;
	displayrect.right=width;
	displayrect.bottom=height;
	displaydepth=depth;

	ddraw2->SetDisplayMode( width, height, depth, rate, 0 );
	curdisplaymode = mode;

	TRACE("------------------- %dx%dx%d (%dhz) ---------------\n", width, height, depth, rate);

	if (CreateFlippingSurfaces()==FALSE)
	{
		TRACE("CreateFlippingSurfaces() failed");
		return FALSE;
	}

	StorePixelFormatData();

	if (CreateCustomSurfaces()==FALSE)
	{
		TRACE("CreateCustomSurfaces() failed");
		return FALSE;
	}

	return TRUE;
}

BOOL DirectDrawWin::ActivateDisplayMode( int mode )
{
	if ( mode<0 || mode>=totaldisplaymodes )
		return FALSE;

	DWORD width = displaymode[mode].width;
	DWORD height = displaymode[mode].height;
	DWORD depth = displaymode[mode].depth;
	
	displayrect.left=0;
	displayrect.top=0;
	displayrect.right=width;
	displayrect.bottom=height;
	displaydepth=depth;

	ddraw2->SetDisplayMode( width, height, depth, 0, 0 );
	curdisplaymode = mode;

	TRACE("------------------- %dx%dx%d ----------------------\n", width, height, depth);

	if (CreateFlippingSurfaces()==FALSE)
	{
		TRACE("CreateFlippingSurfaces() failed");
		return FALSE;
	}

	StorePixelFormatData();

	if (CreateCustomSurfaces()==FALSE)
	{
		TRACE("CreateCustomSurfaces() failed");
		return FALSE;
	}

	return TRUE;
}

BOOL DirectDrawWin::BltSurface( LPDIRECTDRAWSURFACE destsurf, LPDIRECTDRAWSURFACE srcsurf, int x, int y, BOOL srccolorkey )
{
	if (destsurf==0 || srcsurf==0)
		return FALSE;

	BOOL use_fastblt=TRUE;

	DDSURFACEDESC destsurfdesc;
	ZeroMemory( &destsurfdesc, sizeof(destsurfdesc) );
	destsurfdesc.dwSize = sizeof(destsurfdesc);
	destsurf->GetSurfaceDesc( &destsurfdesc );

	CRect destrect;
	destrect.left=0;
	destrect.top=0;
	destrect.right=destsurfdesc.dwWidth;
	destrect.bottom=destsurfdesc.dwHeight;

	DDSURFACEDESC srcsurfdesc;
	ZeroMemory( &srcsurfdesc, sizeof(srcsurfdesc) );
	srcsurfdesc.dwSize = sizeof(srcsurfdesc);
	srcsurf->GetSurfaceDesc( &srcsurfdesc );

	CRect srcrect;
	srcrect.left=0;
	srcrect.top=0;
	srcrect.right=srcsurfdesc.dwWidth;
	srcrect.bottom=srcsurfdesc.dwHeight;
	
	// make sure that there is something to do...
	if (x+srcrect.left>=destrect.right)
		return FALSE;
	if (y+srcrect.top>=destrect.bottom)
		return FALSE;
	if (x+srcrect.right<=destrect.left)
		return FALSE;
	if (y+srcrect.bottom<=destrect.top)
		return FALSE;

	// clip the source rect if nessesary
	if (x+srcrect.right>destrect.right)
		srcrect.right-=x+srcrect.right-destrect.right;
	if (y+srcrect.bottom>destrect.bottom)
		srcrect.bottom-=y+srcrect.bottom-destrect.bottom;

	CRect dr;
	if (x<0)
	{
		srcrect.left=-x;
		x=0;
		dr.left=x;
		dr.top=y;
		dr.right=x+srcrect.Width();
		dr.bottom=y+srcrect.Height();
		use_fastblt=FALSE;
	}

	if (y<0)
	{
		srcrect.top=-y;
		y=0;
		dr.left=x;
		dr.top=y;
		dr.right=x+srcrect.Width();
		dr.bottom=y+srcrect.Height();
		use_fastblt=FALSE;
	}

	DWORD flags;
	if (use_fastblt)
	{
		flags=DDBLTFAST_WAIT;
		if (srccolorkey)
			flags |= DDBLTFAST_SRCCOLORKEY;
		destsurf->BltFast( x, y, srcsurf, &srcrect, flags );
	}
	else
	{
		flags=DDBLT_WAIT;
		if (srccolorkey)
			flags |= DDBLT_KEYSRC;
		destsurf->Blt( &dr, srcsurf, &srcrect, flags, 0 );
	}
	return TRUE;
}

BOOL DirectDrawWin::ClearSurface( LPDIRECTDRAWSURFACE surf, DWORD clr, RECT* rect )
{
	if (surf==0)
		return FALSE;

	DDBLTFX bltfx;
	ZeroMemory( &bltfx, sizeof(bltfx) );
	bltfx.dwSize = sizeof(bltfx);
	bltfx.dwFillColor = clr;

	HRESULT r;
	r=surf->Blt( rect, 0, 0, DDBLT_COLORFILL | DDBLT_WAIT, &bltfx );
	if (r==DD_OK)
		return TRUE;

	if (r==DDERR_NOBLTHW && clr==0 && rect==0)
	{
		DDSURFACEDESC desc;
		ZeroMemory( &desc, sizeof(desc) );
		desc.dwSize = sizeof(desc);
		desc.dwFlags=DDSD_WIDTH | DDSD_HEIGHT;
		if (surf->GetSurfaceDesc( &desc )!=DD_OK)
			return FALSE;
		int w=desc.dwWidth;
		int h=desc.dwHeight;

		r=surf->Lock( 0, &desc, DDLOCK_WAIT  | DDLOCK_WRITEONLY, 0 );
		if (r!=DD_OK)
			return FALSE;

		BYTE* surfbits = (BYTE*)desc.lpSurface;

		for (int i=0;i<h;i++)
		{
			ZeroMemory( surfbits, desc.lPitch );
			surfbits += desc.lPitch;
		}
		surf->Unlock( 0 );
	}
	
	return FALSE;
}

BOOL DirectDrawWin::ClearSurface( LPDIRECTDRAWSURFACE surf, DWORD r, DWORD g, DWORD b, RECT* rect )
{
	if (surf==0)
		return FALSE;

	DDBLTFX bltfx;
	ZeroMemory( &bltfx, sizeof(bltfx) );
	bltfx.dwSize = sizeof(bltfx);
	bltfx.dwFillColor = RGBtoPixel( r, g, b );
	HRESULT ret=surf->Blt( rect, 0, 0, DDBLT_COLORFILL | DDBLT_WAIT, &bltfx );

	return ret==DD_OK;
}

int DirectDrawWin::CompareModes( const void *arg1, const void *arg2 )
{
	DisplayModeInfo* mode1=(DisplayModeInfo*)arg1;
	DisplayModeInfo* mode2=(DisplayModeInfo*)arg2;

	DWORD volume1=mode1->width*mode1->height;
	DWORD volume2=mode2->width*mode2->height;

	if (volume1<volume2)
		return -1;
	else if (volume1>volume2)
		return 1;

	if (mode1->depth<mode2->depth)
		return -1;
	else if (mode1->depth>mode2->depth)
		return 1;
	
	return 0;
}

BOOL DirectDrawWin::Copy_Bmp08_Surface08( LPDIRECTDRAWSURFACE surf, 
										 BYTE* bmpbuf, int w, int h )
{
	if (surf==0 || bmpbuf==0)
		return FALSE;

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize = sizeof(desc);
	HRESULT r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_WRITEONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("ShowBmp: Lock() failed\n");
		return FALSE;
	}
	int bytesgiven=(w+3) & ~3;
	BYTE* surfbits = (BYTE*)desc.lpSurface;
	BYTE* imagebits = (BYTE*)(&bmpbuf[(h-1)*bytesgiven]);
	for( int i=0; i<h; i++ )
	{
		memcpy( surfbits, imagebits, w );
		surfbits += desc.lPitch;
		imagebits -= bytesgiven;
	}
	surf->Unlock( 0 );
	return TRUE;
}

BOOL DirectDrawWin::Copy_Bmp24_Surface16( LPDIRECTDRAWSURFACE surf, 
										 BYTE* bmpbuf, int w, int h )
{
	if (surf==0 || bmpbuf==0)
		return FALSE;
	
	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize = sizeof(desc);
	HRESULT r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_WRITEONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("Copy_Bmp24_Surface16: Lock() failed\n");
		return FALSE;
	}
	int bytesrequired=w*3;
	int bytesgiven=(bytesrequired+3) & ~3;
	BYTE* surfbits = (BYTE*)desc.lpSurface;
	BYTE* imagebits = (BYTE*)(&bmpbuf[(h-1)*bytesgiven]);

	float REDdiv=(float)256/(float)pow( 2, numREDbits );
	float GREENdiv=(float)256/(float)pow( 2, numGREENbits );
	float BLUEdiv=(float)256/(float)pow(2, numBLUEbits );

	for( int i=0; i<h; i++ )
	{
		USHORT* pixptr=(unsigned short*)surfbits;
		RGBTRIPLE* triple=(RGBTRIPLE*)imagebits;
		for (int p=0;p<w;p++)
		{
			float rf=(float)triple->rgbtRed/REDdiv;
			float gf=(float)triple->rgbtGreen/GREENdiv;
			float bf=(float)triple->rgbtBlue/BLUEdiv;

			WORD r=(WORD)((WORD)rf<<loREDbit);
			WORD g=(WORD)((WORD)gf<<loGREENbit);
			WORD b=(WORD)((WORD)bf<<loBLUEbit);
			*pixptr = (WORD)(r|g|b);

			triple++;
			pixptr++;
		}
		surfbits += desc.lPitch;
		imagebits -= bytesgiven;
	}
	surf->Unlock( 0 );

	return TRUE;
}

BOOL DirectDrawWin::Copy_Bmp24_Surface24( LPDIRECTDRAWSURFACE surf, 
										 BYTE* bmpbuf, int w, int h )
{
	if (surf==0 || bmpbuf==0)
		return FALSE;

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize = sizeof(desc);
	HRESULT r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_WRITEONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("Copy_Bmp24_Surface24: Lock() failed\n");
		return FALSE;
	}
	int bytesrequired=w*3;
	int bytesgiven=(bytesrequired+3) & ~3;
	BYTE* surfbits = (BYTE*)desc.lpSurface;
	BYTE* imagebits = (BYTE*)(&bmpbuf[(h-1)*bytesgiven]);

	// check if file and surface format are identical
	// if so, use memcpy() to speed things up
	if (loREDbit==16 && loGREENbit==8 && loBLUEbit==0)
	{
		TRACE("using optimized code...\n");
		for (int i=0;i<h;i++)
		{
			memcpy( surfbits, imagebits, bytesrequired );
			surfbits += desc.lPitch;
			imagebits -= bytesgiven;
		}
	}
	else
	{
		TRACE("not using optimated code...\n");
		for(int i=0; i<h; i++ )
		{
			RGBTRIPLE* surf=(RGBTRIPLE*)surfbits;
			RGBTRIPLE* image=(RGBTRIPLE*)imagebits;
			for (int p=0;p<w;p++)
			{
				DWORD r=image->rgbtRed   << loREDbit;
				DWORD g=image->rgbtGreen << loGREENbit;
				DWORD b=image->rgbtBlue  << loBLUEbit;
				DWORD* data=(DWORD*)surf;
				*data = r|g|b; 
				surf++;
				image++;
			}
			surfbits += desc.lPitch;
			imagebits -= bytesgiven;
		}
	}
	surf->Unlock( 0 );

	return TRUE;
}

BOOL DirectDrawWin::Copy_Bmp24_Surface32( LPDIRECTDRAWSURFACE surf, 
										 BYTE* bmpbuf, int w, int h )
{
	if (surf==0 || bmpbuf==0)
		return FALSE;

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize = sizeof(desc);
	HRESULT r=surf->Lock( 0, &desc, DDLOCK_WAIT | DDLOCK_WRITEONLY, 0 );
	if (r!=DD_OK)
	{
		TRACE("Copy_Bmp24_Surface32: Lock() failed\n");
		return FALSE;
	}
	int bytesrequired=w*3;
	int bytesgiven=(bytesrequired+3) & ~3;
	BYTE* surfbits = (BYTE*)desc.lpSurface;
	BYTE* imagebits = (BYTE*)(&bmpbuf[(h-1)*bytesgiven]);

	for(int i=0; i<h; i++ )
	{
		DWORD* surf=(DWORD*)surfbits;
		RGBTRIPLE* image=(RGBTRIPLE*)imagebits;
		for (int p=0;p<w;p++)
		{
			DWORD r=image->rgbtRed   << loREDbit;
			DWORD g=image->rgbtGreen << loGREENbit;
			DWORD b=image->rgbtBlue  << loBLUEbit;
			DWORD* data=(DWORD*)surf;
			*data = r|g|b; 
			surf++;
			image++;
		}
		surfbits += desc.lPitch;
		imagebits -= bytesgiven;
	}

	surf->Unlock( 0 );

	return TRUE;
}

BOOL DirectDrawWin::Copy_Bmp_Surface( LPDIRECTDRAWSURFACE surf, 
		BITMAPINFOHEADER* bmphdr, BYTE* buf)
{
	if (surf==0 || bmphdr==0 || buf==0)
		return FALSE;
	
	int imagew=bmphdr->biWidth;
	int imageh=bmphdr->biHeight;
	int imagebitdepth=bmphdr->biBitCount;

	BOOL ret=FALSE;
	if (imagebitdepth==8)
	{
		if (displaydepth==8)
			ret=Copy_Bmp08_Surface08( surf, buf, imagew, imageh );
	}
	else if (imagebitdepth==24)
	{
		if (displaydepth==16)
			ret=Copy_Bmp24_Surface16( surf, buf, imagew, imageh );
		else if (displaydepth==24)
			ret=Copy_Bmp24_Surface24( surf, buf, imagew, imageh );
		else if (displaydepth==32)
			ret=Copy_Bmp24_Surface32( surf, buf, imagew, imageh );
	}

	return ret;
}

BOOL DirectDrawWin::Create(const CString& title,int icon)
{
	CString sClassName;

	sClassName = AfxRegisterWndClass(CS_HREDRAW | CS_VREDRAW,LoadCursor(0, IDC_ARROW),
			(HBRUSH)(COLOR_WINDOW + 1), LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(icon)));

	return CWnd::CreateEx( WS_EX_TOPMOST, sClassName, title, WS_POPUP, 0,0,100,100, 0, 0 );
}

BOOL DirectDrawWin::CreateFlippingSurfaces()
{
	if (primsurf)
		primsurf->Release(), primsurf=0;

	DDSURFACEDESC desc;
	ZeroMemory( &desc, sizeof(desc) );
	desc.dwSize = sizeof( desc );
	desc.dwFlags =  DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
	desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
	desc.dwBackBufferCount = 1;
	HRESULT r=ddraw2->CreateSurface( &desc, &primsurf, 0 );
	if (r!=DD_OK)
		return FALSE;

	DDSCAPS surfcaps;
	surfcaps.dwCaps = DDSCAPS_BACKBUFFER;
	r=primsurf->GetAttachedSurface( &surfcaps, &backsurf );
	if (r!=DD_OK)
		return FALSE;

	ClearSurface( primsurf, 0 );
	ClearSurface( backsurf, 0 );

	return TRUE;
}

BOOL DirectDrawWin::CreatePalette(RGBQUAD* quad, int ncolors)
{
	if (palette)
		palette->Release(), palette=0;
	
	PALETTEENTRY pe[256];
	ZeroMemory( pe, sizeof(pe) );
	for( int i=0; i<ncolors; i++)
	{
		pe[i].peRed   = quad[i].rgbRed;
		pe[i].peGreen = quad[i].rgbGreen;
		pe[i].peBlue  = quad[i].rgbBlue;
	}

	HRESULT r=ddraw2->CreatePalette( DDPCAPS_8BIT | DDPCAPS_ALLOW256, 
								pe, &palette, 0 );
	if (r!=DD_OK)
	{
		TRACE("failed to create DirectDraw palette\n");
		return FALSE;
	}

	primsurf->SetPalette( palette );

	return TRUE;
}

LPDIRECTDRAWSURFACE DirectDrawWin::CreateSurface(LPCTSTR filename, BOOL installpalette)
{
	int imagew, imageh;
	GetBmpDimensions( filename, imagew, imageh );
	
	LPDIRECTDRAWSURFACE surf=CreateSurface( imagew, imageh );
	if (surf==0)
	{
		TRACE("CreateSurface(filename) failed to create surface\n");
		return 0;
	}
	
	ifstream bmp( filename, ios::binary | ios::nocreate );
	if (!bmp.is_open())
	{
		TRACE("LoadSurface: cannot open Bmp file\n");
		return 0;
	}

	BITMAPFILEHEADER bmpfilehdr;
	bmp.read( (char*)&bmpfilehdr, sizeof(bmpfilehdr) );
	char* ptr=(char*)&bmpfilehdr.bfType;
	if (*ptr!='B' || *++ptr!='M')
	{
		TRACE("invalid bitmap\n");
		return 0;
	}

	BITMAPINFOHEADER bmpinfohdr;
	bmp.read( (char*)&bmpinfohdr, sizeof(bmpinfohdr) );
	bmp.seekg( sizeof(bmpfilehdr)+bmpinfohdr.biSize, ios::beg );
	int imagebitdepth=bmpinfohdr.biBitCount;

	int imagesize=bmpinfohdr.biSizeImage;
	if (imagesize==0)
		imagesize=((imagew*(imagebitdepth/8)+3) & ~3)*imageh;

	if (bmpinfohdr.biCompression!=BI_RGB)
	{
		TRACE("compressed BMP format\n");
		return 0;
	}

	TRACE("loading '%s': width=%d height=%d depth=%d\n", filename, imagew, imageh, imagebitdepth);

	if (imagebitdepth==8)
	{
		int ncolors;
		if (bmpinfohdr.biClrUsed==0)
			ncolors=256;