runner_game.h

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

#include "runner.h"

#ifndef TAG_RUNNER_GAME
#define TAG_RUNNER_GAME

struct NODE_SHARED   //寻路时公用的路径信息 
{
 UINT8*     buf_ptr;
 UINT8      dire;
 struct NODE_SHARED *last_node_ptr;
};

struct PATH_LINK
{
   UINT8 dire;
   PATH_LINK *next_path_ptr;
};


#define STEP_LIMIT 16384  // 128 * 128

PATH_LINK *SearchPath(UINT8 *block_buf , SINT16 width , SINT16 height , SINT16 sx , SINT16 sy , SINT16 tx , SINT16 ty);
VOID	   DeletePathLink(PATH_LINK **ppPathLink);





#define GRID_TYPE_RHOMBUS	1
#define GRID_TYPE_RECT		2

class GAME_GRID
{

	BYTE	m_bGridType;		
	int		m_iGridSizeX;		//单个格子尺寸
	int		m_iGridSizeY;
	int     m_iGridWidth;		//以格子为单位的尺寸
	int		m_iGridHeight;
	LPBYTE	m_pbAttr;
public:
	
	int		iAttrSize;
	int		iWorldWidth;
	int     iWorldHeight;
	
	LPBYTE	GetAttrPtr()			{ return m_pbAttr;		}
	int		GetGridSizeX()			{ return m_iGridSizeX;	} 
	int		GetGridSizeY()			{ return m_iGridSizeY;	}
	int		GetWorldGridWidth()		{ return m_iGridWidth;	}
	int		GetWorldGridHeight()	{ return m_iGridHeight;	}
	LPRECT  GetGridRect(LPRECT prcGrid)
			{
				prcGrid->left	= 0;
				prcGrid->right	= m_iGridSizeX;
				prcGrid->top	= 0;
				prcGrid->bottom = m_iGridSizeY;
				return prcGrid;
			}
	VOID	GetGridSize(int *piGridSizeX , int *piGridSizeY)
			{
				*piGridSizeX = m_iGridSizeX;
				*piGridSizeY = m_iGridSizeY;
			}	
	
	VOID	GetWorldGridSize(int *piGridWidth , int *piGridHeight)
			{
				*piGridWidth  = m_iGridWidth;
				*piGridHeight = m_iGridHeight;
			}	
	VOID	ClearAttr()	
			{
				ZeroMemory(m_pbAttr , m_iGridWidth * m_iGridHeight); 
			}
	VOID	WorldToGrid(int x , int y , int *piGridX  , int *piGridY)	
			{
				if(m_bGridType==GRID_TYPE_RHOMBUS)
				{
					Coord_2DWorldToGrid(x , y , piGridX  , piGridY  , (float)m_iGridSizeX , (float)m_iGridSizeY , m_iGridWidth); 
				}
				else
				{
					*piGridX = x / m_iGridSizeX;
					*piGridY = y / m_iGridSizeY;
				}
			}
	VOID	GridToWorld(int x , int y , int *piWorldX , int *piWorldY)
			{
				if(m_bGridType==GRID_TYPE_RHOMBUS)
				{
					Coord_GridTo2DWorld(x , y , piWorldX , piWorldY , (float)m_iGridSizeX , (float)m_iGridSizeY , m_iGridWidth); 
				}
				else
				{
					*piWorldX = x * m_iGridSizeX;
					*piWorldY = y * m_iGridSizeY;
				}
			}
	BOOL	IsGridValid(int iGridX , int iGridY)
			{
				if(iGridX < 0 || iGridY < 0 || iGridX >= m_iGridWidth || iGridY >=m_iGridHeight) return FALSE;
				return TRUE;
			}		
	BOOL	IsGridBorder(int iGridX , int iGridY)
			{
				if(!IsGridValid(iGridX , iGridY)) return FALSE;
				if(iGridX==0 || iGridY==0 || iGridX==(m_iGridWidth - 1) || iGridY==(m_iGridHeight - 1))
				{
					return TRUE;
				}
				return FALSE;
			}		
			
	VOID	SetGridValue(int iGridX , int iGridY , BYTE bValue)
			{
				if(!IsGridValid(iGridX , iGridY))	return;
				*(m_pbAttr + iGridY * m_iGridWidth + iGridX) = bValue;
			}
	
	BYTE	GetGridValue(int iGridX , int iGridY)
			{
				if(!IsGridValid(iGridX , iGridY))	return 0;
				return *(m_pbAttr + iGridY * m_iGridWidth + iGridX);
			}
	
	VOID	AttrToTextFile(TCHAR *strFileName)
			{
				DataToTextFile(m_pbAttr , m_iGridWidth , m_iGridHeight , strFileName);
			}
	
	BOOL	LoadAttrFromFile(TCHAR *strFileName);
	VOID	SaveAttrFile(TCHAR *strFileName);
	
	VOID	SetBorderValue(BYTE bValue);
	LPRECT	WorldRectToGridRect(RECT rcWorld , LPRECT prcGrid);
	
	BOOL	Init(int bGridType  , 
				 int iGridSizeX	, int iGridSizeY , 
				 int iGridWidth , int iGridHeight);
			
	GAME_GRID()		{	m_pbAttr	=	NULL; }
	~GAME_GRID()	{	FreeMemory(m_pbAttr); }
};





class GAME_MAP
{
	int		m_iMapAtWorldX;			
	int     m_iMapAtWorldY;
	int     m_iMapWidth;
	int		m_iMapHeight;

public:	
	BOOL    Init(int iMapX , int iMapY , int iMapWidth , int iMapHeight)
			{
				m_iMapAtWorldX = iMapX;
				m_iMapAtWorldY = iMapY;
				m_iMapWidth	   = iMapWidth;
				m_iMapHeight   = iMapHeight;
				return TRUE;
			}
	VOID	GetMapSize(int *piMapWidth , int *piMapHeight)
			{
				*piMapWidth	 = m_iMapWidth;
				*piMapHeight = m_iMapHeight;
			}
	VOID	GetMapXY(int *piMapX , int *piMapY) 
			{
				*piMapX	 = m_iMapAtWorldX;
				*piMapY  = m_iMapAtWorldY;
			}
};








class GAME_SCENE
{
public:	
	
	GAME_GRID	gridWorld;
	GAME_GRID	gridCover;
	GAME_GRID	gridCoverRedraw;
	
	GAME_MAP	mapMain;
	
	LPBYTE		pbBlockPath;
	VOID		ResetPathBlockBuffer() { memcpy(pbBlockPath , gridWorld.GetAttrPtr() , gridWorld.iAttrSize); }
	
	VOID		SetCoverRedrawValue(RECT rcObj , BYTE bValue);
	VOID		SetMapBorderValue(BYTE bValue);					
	
	BOOL		Init();				
	VOID		Release();									
	GAME_SCENE();
	~GAME_SCENE();
};

	



extern int	DirToGrid[8][2];
extern int DirToViewDir[];

struct SPR_INIT
{
	int iWidth;
	int iHeight;
	int iOffsetAtGridX;
	int iOffsetAtGridY;
};

class SPR_CHARACTER
{
public :   
   int		m_iWidth;
   int		m_iHeight;
   int		m_iGridX;
   int		m_iGridY;
   int		m_iNextGridX;
   int		m_iNextGridY;
   int		m_iDestGridX;
   int		m_iDestGridY;

   int		m_iWorldX;
   int		m_iWorldY;
   int		m_iNextWorldX;
   int		m_iNextWorldY;
   
   int		m_iOffsetAtGridX;
   int		m_iOffsetAtGridY;
   
   int		m_iStepX;
   int		m_iStepY;
   
   int		m_iDestWorldX;
   int		m_iDestWorldY;
   
   int		m_iSprDire;
   
   int		m_iMapOffset;
   
   BOOL		m_boInView;

   PATH_LINK  *pPathLink; 
   PATH_LINK  *pCurrentPathLink;

public:
	LPRECT	GetRect(LPRECT prcSpr)
			{
				prcSpr->left	= m_iWorldX;
				prcSpr->right	= m_iWorldX + m_iWidth;
				prcSpr->top		= m_iWorldY;
				prcSpr->bottom	= m_iWorldY + m_iHeight;
				return prcSpr;
			}
	VOID	GetAtWorldXY(int *piWorldX , int *piWorldY)
			{
				*piWorldX = m_iWorldX;
				*piWorldY = m_iWorldY;
			}
	int		GetDire() { return m_iSprDire; }
	VOID	SetSceneRedraw(GAME_SCENE *pScene)
			{
				RECT rc;
				rc.left	  = m_iWorldX;
				rc.right  = m_iWorldX + m_iWidth;
				rc.top	  = m_iWorldY;
				rc.bottom = m_iWorldY + m_iHeight;
				pScene->SetCoverRedrawValue(rc , 1);  
			}
	VOID	SetOffsetAtGrid(int iOffsetX , int iOffsetY)
			{
				m_iOffsetAtGridX = iOffsetX;
				m_iOffsetAtGridY = iOffsetY;
			}
	VOID    GridToWorld(GAME_SCENE *pScene , int x , int y , int *piWorldX , int *piWorldY);
	VOID	Location(GAME_SCENE *pScene , int x , int y , int dire);
	VOID	Dest(GAME_SCENE *pScene , int x , int y);
	
	BOOL	Run(GAME_SCENE *pScene);
	BOOL	ProcessPath(GAME_SCENE *pScene);

	BOOL	Init(SPR_INIT *pSprInit);
	VOID	Release();
	SPR_CHARACTER();
	~SPR_CHARACTER();
};






#endif