graph.cpp

大家好！这是一个网络游戏源码

		rc1.top		= rcInter.top  - DrawY;
		rc1.right	= rc1.left + rcInter.right  - rcInter.left;
		rc1.bottom	= rc1.top  + rcInter.bottom - rcInter.top;
		
		rc1.left+=rcSrc.left;
		rc1.right+=rcSrc.left;
		rc1.top+=rcSrc.top;
		rc1.bottom+=rcSrc.top;
		//rcInter.left-=rcSrc.left;
		//rcInter.right-=rcSrc.left;
		//rcInter.top-=rcSrc.top;
		//rcInter.bottom-=rcSrc.top;

		if(boColorKey)	g_pddsRenderTarget->Blt(&rcInter , pdds , &rc1 , DDBLT_WAIT|DDBLT_KEYSRC , NULL);
		else            g_pddsRenderTarget->Blt(&rcInter , pdds , &rc1 , DDBLT_WAIT , NULL); 
	}
}

int SnapShot = 0;

VOID	DrawChaSurface(LPDIRECTDRAWSURFACE7 pdds , int iDrawX , int iDrawY , int Dire)
{
	RECT	rcSrc;

    rcSrc.left      = SnapShot / 4 * 64;
	rcSrc.right     = rcSrc.left + 64;
	rcSrc.top       = Dire * 96;
	rcSrc.bottom    = rcSrc.top  + 96;

    RECT rcView; 
    rcView.left	  = 0;
    rcView.right  = g_iViewWidth;
    rcView.top    = 0;
    rcView.bottom = g_iViewHeight;

    RECT rc1 , rc2;
    Blit_GetValidRect(&rc1 , &rc2 ,
 					 iDrawX ,	iDrawY ,
				  	 rcView , rcSrc);
    
	g_pddsRenderTarget->Blt(&rc1 , pdds , &rc2 , DDBLT_WAIT|DDBLT_KEYSRC , NULL);
				  	
	//BltSurfaceRect(DrawX , DrawY , pdds , rcSrc , TRUE);
	
	
	SnapShot++;
	if(SnapShot==32) SnapShot = 0;
}

VOID	SetSurfaceColorKey(LPDIRECTDRAWSURFACE7 pdds , DWORD color)
{
	if(pdds==NULL) return;
	DDCOLORKEY color_key;
	color_key.dwColorSpaceLowValue  = color;	
	color_key.dwColorSpaceHighValue = color;
	pdds->SetColorKey(DDCKEY_SRCBLT, &color_key);	
}

#define IMG_HEADER_SIZE 9

VOID ImageFileToRleFile(char *strSrcFileName , char *strObjFileName , DWORD dwColorKey)
{
	LPDIRECTDRAWSURFACE7 pdds;
	pdds = GetSurfaceFromBmpFile24(strSrcFileName);
	if(pdds==NULL) return ;
	int w , h;	GetSurfaceSize(pdds , (LPDWORD)&w , (LPDWORD)&h);
	DDSURFACEDESC2   ddsd;
    INIT_STRUCT(ddsd);
    pdds->Lock(NULL , &ddsd , DDLOCK_READONLY , NULL);		
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
	int iPitch		     =  (int)(ddsd.lPitch / 2);
	
	LPWORD pwRleData = GetRleDataFromSurfaceData(pwSurfaceData , 
		                                         w , h , 
												 iPitch , dwColorKey);
	pdds->Unlock(0);
	if(pwRleData==NULL) 
	{
	   Out("ERR : %s\n" , "GetRleDataFromSurfaceData Failed!");
	   return ;
	}
	RLE_HEADER RleHeader; 
	GetRleHeader(pwRleData , &RleHeader);
	FILE *fp = fopen(strObjFileName , "wb");
	fwrite(pwRleData , RleHeader.dwSize , 1 , fp);
    fclose(fp);
	FreeMemory(pwRleData);
}


VOID ProcessCoverImage(char *strFileName , DWORD color_key)
{
	LPDIRECTDRAWSURFACE7 pdds;
	pdds = GetSurfaceFromBmpFile24(strFileName);
	if(pdds==NULL) return ;
	SINT16 w , h; 
	GetSurfaceSize(pdds , (LPDWORD)&w , (LPDWORD)&h);
	DDSURFACEDESC2          ddsd;
    INIT_STRUCT(ddsd);
    pdds->Lock(NULL , &ddsd , DDLOCK_READONLY , NULL);		
	
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
	UINT16 pitch		 = (int)ddsd.lPitch / 2 ;
	
	int FullRectCount = 0;
	int NullRectCount = 0;
	FILE *fp = fopen("yizhan.cov" , "wb");
	for(int y = 0 ; y < 36 ; y++)
	{
		for(int x = 0 ; x < 25 ; x++)
		{
			int rect_w = 32;
			int rect_h = 16;
			RLE_INFO RleInfo; RleInfo.boFull = FALSE; RleInfo.boNull = FALSE;
			LPWORD pwCurrentData = pwSurfaceData + y * rect_h * pitch + x * rect_w;
			UINT16 *buffer = GetRleBufferFromSurfaceData(pwCurrentData , rect_w , rect_h , pitch , color_key , &RleInfo);
			if(RleInfo.boFull) FullRectCount++;
			if(RleInfo.boNull) NullRectCount++;
			fwrite(buffer , RleInfo.lSize , 1 , fp);
			FreeMemory(buffer);
		}
	}
	pdds->Unlock(0);
	fclose(fp);

	Out("Full Rect : %d\n" , FullRectCount);
	Out("Null Rect : %d\n" , NullRectCount);
}

UINT16 *GetRleBufferFromSurfaceData(UINT16 *pwSurfaceData , int w , int h , int pitch , DWORD c_key , RLE_INFO *pRleInfo)
{
	UINT16 *src_ptr  = pwSurfaceData;
	UINT16 *line_ptr = src_ptr;
	SINT32 data_size = w * h;
	UINT32 color;
	UINT16 *buffer;GetMemory(buffer , UINT16 ,  data_size  + 4096); //预计的buffer大小
	UINT16 count     = 0;
	
	UINT32 valid_color_count = 0;
	UINT32 buf_byte  = 0;
	UINT32 color_start_byte;
	
	//开始对整个表面进行扫描
	
	SINT16 left    =  w;
	SINT16 right   =  0;
	SINT16 top     = -1;
	SINT16 bottom  =  0;
	
	SINT16 sx = 0;
	
	buf_byte+=IMG_HEADER_SIZE;	//留出18个字节的头信息
	
	SINT32 all_valid_color = 0;
	UINT32 line_start_byte = 0;
	
	SINT16 valid_piece_count = 0;
	SINT16 first_x = 0;
	
	for(SINT16 y = 0 ; y < h ; y++)
	{
		line_ptr = src_ptr;
	    count    = 0;
		*(buffer + buf_byte) = 0;
		line_start_byte = buf_byte;
		buf_byte++;
		valid_color_count = 0;
		valid_piece_count = 0;
		for(SINT16 x = 0 ; x < w ; x++)
		{
			color = *line_ptr;
			
			if(color!=c_key)
			{
				if(count==0) //有效颜色开始
				{
					if(x < left) left = x; 
					sx = x;
					*(buffer + buf_byte) = x; //记住起点
					buf_byte++;
					*(buffer + buf_byte) = 0; //预留出来用来存储颜色个数
					color_start_byte     = buf_byte;
					buf_byte++;
					
					*(buffer + buf_byte) = color;
					buf_byte++;
					count                = 1;
				    if(valid_color_count==0) first_x = x;
					//fprintf(fp1 , "^");
					valid_color_count++;
					valid_piece_count++;
				}
			    else
				{
					*(buffer + buf_byte) = color;
					buf_byte++;  
					count++;
					//fprintf(fp1 , "^");
				}
			}
			else
			{	
				if(count)
				{
					*(buffer + color_start_byte)   = count;
				    valid_color_count+= (count - 1);
					if((sx + count) > right) right = sx + count;
					count                          = 0;
				}
			    //fprintf(fp1 , "-");
			}
			
			line_ptr++;
		}
	    
	    if(count)
		{
			*(buffer + color_start_byte) = count;
		    valid_color_count+= (count - 1);
			if( ( sx + count - 1) > right) right = sx + count - 1;
			count                        = 0;
		}
		
		if(valid_color_count!=0) //记录最上和最下
		{
			if(top < 0 ) top = y;
		    bottom = y;
		}
		*(buffer + line_start_byte) = (valid_color_count + valid_piece_count * 2 );
        all_valid_color+=valid_color_count;
		//fprintf(fp1 , "(%2d , %2d)\n" , first_x , valid_color_count);
		src_ptr+=pitch;
	}

	//fprintf(fp1 , "all_valid_color = %d\n" , all_valid_color);
	//存储头信息
	UINT32 size   = buf_byte  * 2;
	
	*(buffer + 0) = (size>>16);
	*(buffer + 1) = (size & 0x0000FFFF);
	*(buffer + 2) = w;
	*(buffer + 3) = h;
	
	*(buffer + 4) = left;
	*(buffer + 5) = right;
	*(buffer + 6) = top;
	*(buffer + 7) = bottom;

	if(all_valid_color==data_size) 
	{
		*(buffer + 8) = 1;
		pRleInfo->boFull = TRUE;
	}
	else
	{
		*(buffer + 8) = 0;
	}
    if(all_valid_color==0)
	{
		pRleInfo->boNull = TRUE;
	}
	pRleInfo->lSize = size;
	UINT16 *pwBuffer; GetMemory(pwBuffer , UINT16 , buf_byte);
	memcpy(pwBuffer , buffer , size);
	FreeMemory(buffer);
	return pwBuffer;
}




LPWORD pwCoverData;

/*
BLIT 一段BUFFER
参数 : 
表面指针 
BUFFER
BUFFER的尺寸
起点 SX , SY
CLIPPER SX , EX , SY , EY
*/

#define BLIT_IMAGE_BUFFER(SURFACE_PTR , BUF , SIZE , SX , SY  , CLIPPER_SX , CLIPPER_EX , CLIPPER_SY , CLIPPER_EY , EDGE_COLOR)	\
	SINT16 line_count = 0  , line_data_count , x , ori_x , count , ori_count , line_valid;   \
    UINT32 n = 0;               \
    while(n < SIZE) {							\
	line_valid = *BUF ; BUF++;			 \
	if( (SY + line_count) >= CLIPPER_SY ) {			\
	 if( (line_count + SY) >= CLIPPER_EY ) break;	\
		 if(line_valid)  { \
	      line_data_count = 0; \
	      while(1)    \
		  { \
			  x = *BUF; BUF++; \
			  count = *BUF; BUF++; \
			  x+=SX;  \
			  ori_count = count; \
			  ori_x     = x; \
			  if( x < CLIPPER_SX )			  { count = x + count - CLIPPER_SX; x = CLIPPER_SX; } \
			  if( (x + count) >= CLIPPER_EX ) { count = CLIPPER_EX - x; } \
			  if( count>0 ) \
				{ \
				memcpy(SURFACE_PTR + x , BUF + x - ori_x , count * 2); \
				if(EDGE_COLOR!=0)	{	*(SURFACE_PTR + x) = EDGE_COLOR; *(SURFACE_PTR + x + count - 1) = EDGE_COLOR ;} \
				}\
				BUF+=ori_count; \
			  line_data_count+=(ori_count + 2); \
			  if(line_data_count==line_valid) break; \
		  } \
	  } \
	  } \
	  else { \
	      BUF+=line_valid; \
	  } \
	  n+=line_valid; \
	  n++;  \
	  SURFACE_PTR+=pitch; \
	  line_count++;   \
	}

VOID	DrawCover(int DrawX , int DrawY)
{
	SINT16 clipper_sx = 0;
	SINT16 clipper_ex = 800;
	SINT16 clipper_sy = 0;
	SINT16 clipper_ey = 600;
	
	LPDIRECTDRAWSURFACE7 pdds = g_pddsRenderTarget;
	SINT16 w , h; GetSurfaceSize(pdds , (LPDWORD)&w , (LPDWORD)&h);
	DDSURFACEDESC2  ddsd;
	INIT_STRUCT(ddsd);
	pdds->Lock(NULL , &ddsd , DDLOCK_WRITEONLY , NULL);		
	
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
	UINT16 pitch		 = (int)ddsd.lPitch / 2 ;

	LPWORD pwCurSurfaceData = pwSurfaceData;
	int Rect = 0;
	LPWORD pwCurrentCoverData = pwCoverData;
	int FullRectCount = 0;
	while(Rect < 1) 
	{
		UINT16 size1 = *(pwCurrentCoverData + 0);
		UINT16 size2 = *(pwCurrentCoverData + 1);
		UINT32 size  = size1;
		size<<=16;
		size|=size2;  
		size>>=1;
		//Out("size = %d\n" , size);
		pwCurrentCoverData+=IMG_HEADER_SIZE;
		size-=IMG_HEADER_SIZE;
		UINT32 s = size;
		LPWORD pwTemp	= pwCurSurfaceData;
		LPWORD pwTemp1  = pwCurrentCoverData; 
		BLIT_IMAGE_BUFFER(pwTemp , pwTemp1 , s , 
					DrawX , DrawY , 
					clipper_sx , clipper_ex , clipper_sy , clipper_ey , 
					0);
		//if(*(pwCurrentCoverData + 8)) FullRectCount++;
		pwCurrentCoverData+=size;
		pwCurSurfaceData+=32;
		Rect++;
		if(Rect % 25==0) 
		{
			pwSurfaceData+=(16 * pitch);
			pwCurSurfaceData = pwSurfaceData;
		}
	}
	pdds->Unlock(0);
	//Out("DrawCover FullRectCount = %d\n" , FullRectCount);
	//FreeMemory(pwCoverData);
}

	

LPDIRECTDRAWSURFACE7	GetSurfaceFromRleFile16(char *strFileName)
{
	long lFileSize = GetFileSize(strFileName);
	FILE *fp = fopen(strFileName , "rb");
	if(fp==NULL)
	{
		Out("ERR : Rle File not Found <%s>\n" , strFileName); 
	    return NULL;
	}
	LPWORD pwRleData;GetMemory(pwRleData , WORD , lFileSize / 2);
    fread(pwRleData , lFileSize , 1 , fp);
    fclose(fp);
	RLE_HEADER RleHeader;
	GetRleHeader(pwRleData , &RleHeader);
	int w = RleHeader.wWidth;
	int h = RleHeader.wHeight;
	LPDIRECTDRAWSURFACE7 pdds = CreateSurface(w , h , SURFACE_TYPE_NORMAL);
	if(pdds==NULL) 
	{
		FreeMemory(pwRleData);
		return NULL;
	}
    DDSURFACEDESC2  ddsd;
	INIT_STRUCT(ddsd);
	pdds->Lock(NULL , &ddsd , DDLOCK_WRITEONLY , NULL);		
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
	
	GetSurfaceDataFromRleData(pwSurfaceData , pwRleData , ddsd.lPitch / 2);
	
	pdds->Unlock(0);
	SetSurfaceColorKey(pdds , RleHeader.dwColorKey);
	FreeMemory(pwRleData);
	return 	pdds;
}

LPRECT	WorldRectToViewRect(LPRECT prcWorld)
{
	prcWorld->left-=g_iViewAtWorldX;	
	prcWorld->right-=g_iViewAtWorldX;	
	prcWorld->top-=g_iViewAtWorldY;	
	prcWorld->bottom-=g_iViewAtWorldY;
	return prcWorld;
}

VOID DrawRect(RECT rc , DWORD dwColor)
{
	HDC hDC;
	if( SUCCEEDED( g_pddsRenderTarget->GetDC(&hDC) ) )
	{
		HPEN hPen = CreatePen(PS_SOLID , 1 , dwColor);
		SelectObject(hDC , hPen);
		
		POINT pt;
		MoveToEx(hDC , rc.left , rc.top , &pt);
		LineTo(hDC , rc.right , rc.top);
		LineTo(hDC , rc.right , rc.bottom);
		LineTo(hDC , rc.left  , rc.bottom);
		LineTo(hDC , rc.left  , rc.top);

		DeleteObject(hPen);
		g_pddsRenderTarget->ReleaseDC(hDC);
	}
}