scene_view.cpp

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

VOID SCENE_VIEW::DrawMap(GAME_MAP *pmapMain)
{
	int iMapX , iMapY;	pmapMain->GetMapXY(&iMapX , &iMapY);
	int iMapInViewX = iMapX - g_iViewAtWorldX;
	int iMapInViewY = iMapY - g_iViewAtWorldY;
	BltSurface(iMapInViewX , iMapInViewY , psurMap , FALSE);
}

VOID SCENE_VIEW::DrawGridAttrColor()
{
	D3DXMATRIX matWorld;
	D3DXMatrixIdentity(&matWorld);
 	g_pd3dDevice->SetTransform( D3DTRANSFORMSTATE_WORLD , matWorld );

	g_pd3dDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE);
	g_pd3dDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA);
	g_pd3dDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
    g_pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP  , D3DTOP_MODULATE);
		
		
	g_pd3dDevice->SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, TRUE);
	g_pd3dDevice->SetRenderState( D3DRENDERSTATE_ZENABLE	  , FALSE );
	g_pd3dDevice->SetRenderState( D3DRENDERSTATE_LIGHTING, TRUE);
    g_pd3dDevice->SetRenderState(  D3DRENDERSTATE_AMBIENT, RGB_MAKE(255 , 0 , 0) );
	   
	g_pd3dDevice->SetTexture(0 , psurAttr);

	g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP , D3DFVF_XYZ|D3DFVF_TEX1 , 
		                         pAttrVB , 4 , 0);
	
	g_pd3dDevice->SetTexture(0 , 0);
	//g_pd3dDevice->SetRenderState(  D3DRENDERSTATE_AMBIENT, 0);
	g_pd3dDevice->SetRenderState( D3DRENDERSTATE_LIGHTING, FALSE);
	g_pd3dDevice->SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, FALSE);
	g_pd3dDevice->SetRenderState( D3DRENDERSTATE_ZENABLE	  , TRUE );
	g_pd3dDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE,FALSE);
}

VOID SCENE_VIEW::DrawGridAttrChar()
{
	/*
	HDC hDC;
	if( g_pddsRenderTarget )
	{
		if( SUCCEEDED( g_pddsRenderTarget->GetDC(&hDC) ) )
		{
			SetTextColor( hDC, RGB(255 , 255 , 255));
			SetBkMode( hDC, TRANSPARENT );
           
			int iOffsetY;
			for(int y = 0 ; y < m_iGridNum ; y++)
			{
				iOffsetY = y * m_iGridNum;
				for(int x = 0 ; x < m_iGridNum ; x++)
				{
					int iOffset = iOffsetY + x;
					if(*(pbAttr + iOffset)==1)
					{
						int iWorldX , iWorldY; 
						GridToWorld(x , y , &iWorldX , &iWorldY);
        				int DrawX = iWorldX - iViewAtWorldX - 6;
						int DrawY = iWorldY - iViewAtWorldY + (int)(m_fGridSizeY / 2.0f) - 6; 
						
						if(DrawX < -8 || DrawY < -8 || DrawX > g_iViewWidth || DrawY > g_iViewHeight) continue;
	
						TCHAR *str = "B";
						ExtTextOut( hDC, DrawX, DrawY, 0, NULL, str, lstrlen(str), NULL);
					}	    
				}
			}
			g_pddsRenderTarget->ReleaseDC(hDC);
		}
	}*/
}

VOID SCENE_VIEW::SetAttrSurface(GAME_GRID *pgridWorld , DWORD dwColor)
{
	DDSURFACEDESC2          ddsd;
	INIT_STRUCT(ddsd);
    psurAttr->Lock(NULL , &ddsd , DDLOCK_READONLY , NULL);
	DWORD w = ddsd.dwWidth;
	DWORD h = ddsd.dwHeight;
	
	DWORD pitch = (DWORD)ddsd.lPitch / 2;
	
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
   
	LPBYTE pbAttrData = pgridWorld->GetAttrPtr();
	int iGridWidth	  = pgridWorld->GetWorldGridWidth();
	DWORD x , y , color;
	for(y = 0 ; y < h ; y++)
	{
       for(x = 0 ; x < w ; x++)
	   {
	       if(*(pbAttrData + x)==1)		color = dwColor;
		   else							color = 0;
		   
		   *(pwSurfaceData + x) = (WORD)color;            
	   }
	   pwSurfaceData+=pitch;
	   pbAttrData+=iGridWidth;
	}
	psurAttr->Unlock(NULL);

}

VOID SCENE_VIEW::SetAttrSurfaceValue(int x , int y , DWORD dwColor)
{
	DDSURFACEDESC2          ddsd;
	INIT_STRUCT(ddsd);
    psurAttr->Lock(NULL , &ddsd , DDLOCK_WRITEONLY , NULL);
	DWORD pitch = (DWORD)ddsd.lPitch / 2;
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface + y * pitch + x;
    *pwSurfaceData = (WORD)dwColor;
	psurAttr->Unlock(NULL);
}


VOID SCENE_VIEW::DrawCover(GAME_MAP *pmapMain , GAME_GRID *pgridCoverRedraw)
{
	int iMapX      , iMapY     ; pmapMain->GetMapXY(&iMapX , &iMapY);
	int iWidth     , iHeight   ; pgridCoverRedraw->GetWorldGridSize(&iWidth , &iHeight);
	int iGridSizeX , iGridSizeY; pgridCoverRedraw->GetGridSize(&iGridSizeX  , &iGridSizeY);
	
	LPBYTE pbRedraw	= pgridCoverRedraw->GetAttrPtr();
	
	for(int y = 0 ; y < iHeight ; y++) 
	{
		for(int x = 0 ; x < iWidth ; x++)
		{
			if(*(pbRedraw + x))
			{
				  RECT rcSrc;
				  rcSrc.left	= x * iGridSizeX;
				  rcSrc.right	= rcSrc.left + iGridSizeX;
				  rcSrc.top		= y * iGridSizeY;
				  rcSrc.bottom	= rcSrc.top + iGridSizeY;
				  
				  RECT rcView; 
				  rcView.left	= 0;
				  rcView.right	= g_iViewWidth;
				  rcView.top    = 0;
				  rcView.bottom = g_iViewHeight;

				  RECT rc1 , rc2;
				  Blit_GetValidRect(&rc1 , &rc2 ,
									iMapX + rcSrc.left - g_iViewAtWorldX ,
									iMapY + rcSrc.top  - g_iViewAtWorldY ,
				 					rcView , rcSrc);
				  
				  g_pddsRenderTarget->Blt(&rc1 , psurCover , &rc2 , DDBLT_WAIT|DDBLT_KEYSRC , NULL);
				  
				  
			}
		}
		pbRedraw+=iWidth;
	}

}
	

VOID SCENE_VIEW::DrawCoverRedrawRect(GAME_MAP *pmapMain	, GAME_GRID *pgridCoverRedraw)
{
	int iMapX , iMapY ; pmapMain->GetMapXY(&iMapX , &iMapY);
	int iWidth     , iHeight   ; pgridCoverRedraw->GetWorldGridSize(&iWidth , &iHeight);
	int iGridSizeX , iGridSizeY; pgridCoverRedraw->GetGridSize(&iGridSizeX  , &iGridSizeY);
	
	LPBYTE pbRedraw = pgridCoverRedraw->GetAttrPtr();
	for(int y = 0 ; y < iHeight ; y++) 
	{
		for(int x = 0 ; x < iWidth ; x++)
		{
			if(*(pbRedraw + x))
			{
				 RECT rcSrc;
				 rcSrc.left		= x * iGridSizeX + iMapX;
				 rcSrc.right	= rcSrc.left + iGridSizeX;
			     rcSrc.top		= y * iGridSizeY + iMapY;
			     rcSrc.bottom	= rcSrc.top + iGridSizeY;
				 WorldRectToViewRect(&rcSrc);
				 DrawRect(rcSrc , RGB(0 , 255 , 0));
			}
		}
		pbRedraw+=iWidth;
	}
}

VOID SCENE_VIEW::DrawCoverAttr(GAME_MAP *pmapMain ,  GAME_GRID *pgridCover)
{
	int iMapX , iMapY ; pmapMain->GetMapXY(&iMapX , &iMapY);
	int iWidth     , iHeight   ; pgridCover->GetWorldGridSize(&iWidth , &iHeight);
	int iGridSizeX , iGridSizeY; pgridCover->GetGridSize(&iGridSizeX  , &iGridSizeY);
	
	LPBYTE pbCover = pgridCover->GetAttrPtr();
	HDC hDC;
	if( g_pddsRenderTarget )
	{
		if( SUCCEEDED( g_pddsRenderTarget->GetDC(&hDC) ) )
		{
			SetTextColor( hDC, RGB(255 , 255 , 255));
			SetBkMode( hDC, TRANSPARENT );
			for(int y = 0 ; y < iHeight ; y++) 
			{
				for(int x = 0 ; x < iWidth ; x++)
				{
					BYTE bHeight = *(pbCover + x);
					if(bHeight)
					{
						RECT rcSrc;
						rcSrc.left		= x * iGridSizeX + iMapX;
						rcSrc.right		= rcSrc.left + iGridSizeX;
						rcSrc.top		= y * iGridSizeY + iMapY;
						rcSrc.bottom	= rcSrc.top + iGridSizeY;
						WorldRectToViewRect(&rcSrc);
						int iDrawX = x * iGridSizeX + iMapX - g_iViewAtWorldX;
						int iDrawY = y * iGridSizeY + iMapY - g_iViewAtWorldY;
						if(iDrawX < -8 || iDrawY < -8 || iDrawX > g_iViewWidth || iDrawY > g_iViewHeight) continue;
						TCHAR str[4]; itoa(bHeight , str , 10);
						ExtTextOut( hDC, iDrawX , iDrawY, 0, NULL, str , lstrlen(str), NULL);
					}
				}
				pbCover+=iWidth;
			}
			g_pddsRenderTarget->ReleaseDC(hDC);
		}
	}

}


VOID SCENE_VIEW::DrawGrid(int iDrawX , int iDrawY , GAME_GRID *pGrid , DWORD dwColor)
{
	int iGridSizeX , iGridSizeY; pGrid->GetGridSize(&iGridSizeX , &iGridSizeY);
	int iWidth , iHeight;		 pGrid->GetWorldGridSize(&iWidth , &iHeight);
	
	int iLineWidth  = iWidth  * iGridSizeX;
	int iLineHeight = iHeight * iGridSizeY;
	HDC hDC;
	
	if( SUCCEEDED( g_pddsRenderTarget->GetDC(&hDC) ) )
	{
		HPEN hPen = CreatePen(PS_SOLID , 1 , dwColor);
		SelectObject(hDC , hPen);
		
		POINT pt;
		
		int iOffsetY = iDrawY;
		int iOffsetX = iDrawX;
		
		for(int y = 0 ; y <= iHeight ; y++)
		{
			MoveToEx(hDC , iDrawX , iOffsetY , &pt);
			LineTo(hDC , iDrawX + iLineWidth , iOffsetY);
			iOffsetY+=iGridSizeY;
		}
		
		for(int x = 0 ; x <= iWidth ; x++)
		{
			MoveToEx(hDC , iOffsetX , iDrawY , &pt);
			LineTo(hDC , iOffsetX , iDrawY + iLineHeight);
			iOffsetX+=iGridSizeX;
		}
		DeleteObject(hPen);
		g_pddsRenderTarget->ReleaseDC(hDC);
	}
	
} 


VOID SCENE_VIEW::Scroll(int Dir)
{
	switch(Dir)
	{
		// SCroll Left
		case 1:		m_Camera.Move(MOVE_LEFT);		break;
		// SCroll Right
		case 2:		m_Camera.Move(MOVE_RIGHT);		break;
		// SCroll Up	
		case 3:		m_Camera.Move(MOVE_FORWARD);	break;
		// SCroll Down
		case 4:		m_Camera.Move(MOVE_BACKWARD);	break;
	}
}