game_editor.cpp

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

#include "runner_game.h"
#include "game_editor.h"


BOOL GAME_EDITOR::Init()
{
	
	SetEditorTarget(EDITOR_TARGET_WORLD); 
	
	EditorState.iWorldAttrShowMode  = WORLD_ATTR_COLOR;
    EditorState.boShowChaPath = TRUE;
	
	GetMemoryI(pSceneView , SCENE_VIEW);
	GetMemoryI(pScene	  , GAME_SCENE);
	GetMemoryI(pMan		  , SPR_CHARACTER);
	GetMemoryI(pSprView   , SPR_VIEW);
		
	pScene->gridWorld.Init(GRID_TYPE_RHOMBUS , 48 , 24 , 64 , 64);
		
	pScene->gridCover.Init(GRID_TYPE_RECT , 32 , 16 , 25 , 36);
	pScene->gridCoverRedraw.Init(GRID_TYPE_RECT , 32 , 16 , 25 , 36);
	pScene->mapMain.Init(1110 , 248 , 800 , 576);
	pScene->Init();
		
	pScene->gridWorld.LoadAttrFromFile("yizhan.atr");
	pScene->gridCover.LoadAttrFromFile("yizhan.cov");
		
	SCENE_VIEW_INIT SceneViewInit;
	SceneViewInit.fGridSize	= 3.394f;
	SceneViewInit.iGridNum	= 64;
	strcpy(SceneViewInit.strMapFileName	  , "yizhan.sur");
	strcpy(SceneViewInit.strCoverFileName , "yizhan.rle");

	pSceneView->Init(&SceneViewInit);

	SPR_VIEW_INIT SprViewInit;
	strcpy(SprViewInit.strSprFileName , "man008_walk.sur");
	pSprView->Init(&SprViewInit);	
	
	pSceneView->SetAttrSurface(&pScene->gridWorld , COLOR_RED);
	
	SPR_INIT SprInit;
	SprInit.iWidth  = 64;
	SprInit.iHeight = 96;
	SprInit.iOffsetAtGridX = -1 * (SprInit.iWidth / 2) ;
	SprInit.iOffsetAtGridY = -1 * (SprInit.iHeight - pScene->gridWorld.GetGridSizeY() / 2 - 6);

	pMan->Init(&SprInit);
	pMan->Location(pScene , 24 , 24 , 1);
		
	return TRUE;
}

VOID GAME_EDITOR::Release()
{
	FreeMemory(pScene);
	FreeMemory(pSceneView);
	FreeMemory(pMan);
	FreeMemory(pSprView);
}

VOID GAME_EDITOR::ReleaseDeviceObj()
{
	pSceneView->ReleaseDeviceObj();
	pSprView->ReleaseDeviceObj();
}

BOOL GAME_EDITOR::Run()
{
	pSceneView->SetView();
	pSceneView->CaluGridInfo();
	
	
	pScene->gridWorld.WorldToGrid(g_iMouseX + g_iViewAtWorldX ,
								  g_iMouseY + g_iViewAtWorldY ,
								  &iMouseAtWorldGridX		  ,
								  &iMouseAtWorldGridY);

	int iMapX , iMapY; pScene->mapMain.GetMapXY(&iMapX , &iMapY);
	
	pScene->gridCover.WorldToGrid(g_iMouseX + g_iViewAtWorldX - iMapX,
								  g_iMouseY + g_iViewAtWorldY - iMapY,
								  &iMouseAtCoverGridX		  ,
								  &iMouseAtCoverGridY);
	
	sprintf(strMouseInfo , "Mouse Grid : World(%d , %d)  Cover(%d , %d)" , iMouseAtWorldGridX , iMouseAtWorldGridY , iMouseAtCoverGridX , iMouseAtCoverGridY);
	pMan->Run(pScene);

	HandleKeyboard(); 
	
	return TRUE;
}

BOOL GAME_EDITOR::DrawAll()
{
	pScene->gridCoverRedraw.ClearAttr();
		
	if(EditorState.boShowMap)
	{	
		pSceneView->DrawMap(&pScene->mapMain);
	}
		
	if(EditorState.boShowWorldGrid)
	{
		pSceneView->DrawGridObj();
	}
	
	if(EditorState.boShowWorldAttr)
	{
		if(EditorState.iWorldAttrShowMode==WORLD_ATTR_COLOR)
		{
			pSceneView->DrawGridAttrColor(); 
		}
		else
		{
			
		}
	}
	
	if(EditorState.boShowChaPath)
	{
		pSprView->DrawSprPath(pScene , pMan);
	}
	
    if(EditorState.boShowCha)
	{
		pSprView->DrawSpr(pMan);
		pMan->SetSceneRedraw(pScene); 
	}
	
	
	if(EditorState.boShowMap)
	{
		pSceneView->DrawCover(&pScene->mapMain , &pScene->gridCoverRedraw);
	}

	if(EditorState.boShowCoverGrid)
	{
		int iMapX , iMapY; pScene->mapMain.GetMapXY(&iMapX , &iMapY);
		pSceneView->DrawGrid(iMapX - g_iViewAtWorldX , iMapY - g_iViewAtWorldY , &pScene->gridCover , RGB(128 , 128 , 128));
	}
	
	if(EditorState.boShowCha && EditorState.boShowChaRect)
	{
		RECT rcSpr;
		pMan->GetRect(&rcSpr);
		WorldRectToViewRect(&rcSpr);
		DrawRect(rcSpr , RGB(255 , 255 , 255));
	}
	
	if(EditorState.boShowCoverAttr)
	{
		pSceneView->DrawCoverAttr(&pScene->mapMain , &pScene->gridCover);
		if(EditorState.boShowCoverRedrawRect)
		{
			pSceneView->DrawCoverRedrawRect(&pScene->mapMain , &pScene->gridCoverRedraw);
		}
	}

	pSceneView->DrawSingleGridObj(iMouseAtWorldGridX , iMouseAtWorldGridY);
	OutputText(10 , 20 , strMouseInfo		, COLOR_WHITE);
	OutputText(10 , 38 , strEditorTarget	, COLOR_WHITE);
	return TRUE;
}

BOOL GAME_EDITOR::HandleMouse(int iMouseState)
{
	
	switch(EditorState.iEditorTarget)
	{
			case EDITOR_TARGET_RUN:
				{
					if(iMouseState==1)
					{
						if(EditorState.boCharMove)
						{
							pMan->Dest(pScene , iMouseAtWorldGridX , iMouseAtWorldGridY);
						}
					}
					if(iMouseState==2)
					{
					
					}
					break;
				}
			case EDITOR_TARGET_COVER:
				{
					if(iMouseState==1)
					{
						if(g_iKey[RKEY_CTRL])
						{
							BYTE bHeight;
							if(GetCoverHeight(iMouseAtCoverGridX , iMouseAtCoverGridY , &bHeight))
							{
								SetCoverHeight(iMouseAtCoverGridX , iMouseAtCoverGridY , bHeight + 1);
							}
						}
						else
						{
							if(EditorState.boCharMove)
							{
								pMan->Dest(pScene , iMouseAtWorldGridX , iMouseAtWorldGridY);
							}
						}
					}
					if(iMouseState==2)
					{
						if(g_iKey[RKEY_CTRL])
						{
							BYTE bHeight;
							if(GetCoverHeight(iMouseAtCoverGridX , iMouseAtCoverGridY , &bHeight))
							{
								SetCoverHeight(iMouseAtCoverGridX , iMouseAtCoverGridY , bHeight - 1);
							}
						}
					}
					break;
				}
			case EDITOR_TARGET_WORLD:
				{
					if(iMouseState==1)
					{
						if(EditorState.boCharMove)
						{
							pMan->Dest(pScene , iMouseAtWorldGridX , iMouseAtWorldGridY);
						}
					}
					if(iMouseState==2)
					{
						if(pScene->gridWorld.IsGridValid(iMouseAtWorldGridX , iMouseAtWorldGridY) && !pScene->gridWorld.IsGridBorder(iMouseAtWorldGridX , iMouseAtWorldGridY))
						{	
							if(pScene->gridWorld.GetGridValue(iMouseAtWorldGridX , iMouseAtWorldGridY)==0)
							{
								pScene->gridWorld.SetGridValue(iMouseAtWorldGridX , iMouseAtWorldGridY , 1);
								pSceneView->SetAttrSurfaceValue(iMouseAtWorldGridX , iMouseAtWorldGridY , COLOR_RED);
							}
							else
							{
								pScene->gridWorld.SetGridValue(iMouseAtWorldGridX , iMouseAtWorldGridY , 0);
								pSceneView->SetAttrSurfaceValue(iMouseAtWorldGridX , iMouseAtWorldGridY , 0);
							}
						}			
					}
					break;
				}
		}
	
	return TRUE;
}

BOOL GAME_EDITOR::HandleKeyboard()
{
	if(g_iKey[RKEY_S]) 
	{
		pSceneView->Scroll(1);  
	}
	if(g_iKey[RKEY_F])
	{
		pSceneView->Scroll(2); 
	}
	if(g_iKey[RKEY_E])
	{
		pSceneView->Scroll(3); 
	}
	if(g_iKey[RKEY_D])
	{
		pSceneView->Scroll(4); 
	}
	
	if(g_iKey[RKEY_ALT]||g_iKey[RKEY_CTRL])
	{
		if(EditorState.iEditorTarget==EDITOR_TARGET_WORLD)
		{
			int iGridX , iGridY;
			pScene->gridWorld.WorldToGrid(g_iMouseX + g_iViewAtWorldX , 
										  g_iMouseY + g_iViewAtWorldY ,
										  &iGridX , &iGridY);
			if(pScene->gridWorld.IsGridValid(iGridX , iGridY) && !pScene->gridWorld.IsGridBorder(iGridX , iGridY))
			{
				if(g_iKey[RKEY_CTRL])
				{
					if(pScene->gridWorld.GetGridValue(iGridX , iGridY)==0)
					{
						pScene->gridWorld.SetGridValue(iGridX , iGridY , 1);
						pSceneView->SetAttrSurfaceValue(iGridX , iGridY , COLOR_RED);
					}
				}
				if(g_iKey[RKEY_ALT])
				{
					if(pScene->gridWorld.GetGridValue(iGridX , iGridY)==1)
					{
						pScene->gridWorld.SetGridValue(iGridX , iGridY , 0);
						pSceneView->SetAttrSurfaceValue(iGridX , iGridY , 0);
					} 
				}
			}
		}
	}
	
	//存档
	if(g_iKey[RKEY_F2])
	{
		pScene->gridWorld.SaveAttrFile("yizhan.atr");
		pScene->gridCover.SaveAttrFile("yizhan.cov");
	}
	
	//功能切换
	if(g_iKey[RKEY_F5])	SetEditorTarget(EDITOR_TARGET_WORLD);
	if(g_iKey[RKEY_F6])	SetEditorTarget(EDITOR_TARGET_COVER);
	if(g_iKey[RKEY_F7])	SetEditorTarget(EDITOR_TARGET_RUN);
	
	
	
	return TRUE;
}


BOOL GAME_EDITOR::GetCoverHeight(int iGridX , int iGridY , LPBYTE pbHeight)
{
	if(!pScene->gridCover.IsGridValid(iGridX , iGridY))	return FALSE;
    *pbHeight = pScene->gridCover.GetGridValue(iGridX , iGridY);
	return TRUE;
}

VOID GAME_EDITOR::SetCoverHeight(int iGridX , int iGridY , BYTE bHeight)
{
	if(!pScene->gridCover.IsGridValid(iGridX , iGridY))	return;
	if(bHeight>16) return;
	pScene->gridCover.SetGridValue(iGridX , iGridY , bHeight);
}

VOID GAME_EDITOR::SetEditorTarget(int iTarget)
{
	EditorState.iEditorTarget = iTarget;
	switch(iTarget)
	{
		case EDITOR_TARGET_WORLD:
			{
				EditorState.boShowCoverGrid			= FALSE;
				EditorState.boShowWorldGrid			= TRUE;
				EditorState.boShowWorldAttr			= TRUE;
				EditorState.boShowCoverAttr			= FALSE;
				EditorState.boShowCoverRedrawRect   = FALSE;
				EditorState.boShowMap				= TRUE;
				EditorState.boShowCha				= TRUE;
				EditorState.boShowChaRect			= FALSE;
				EditorState.boCharMove				= TRUE;
				strcpy(strEditorTarget , "编辑器 : 障碍 , 出口");
				break;
			}
		case EDITOR_TARGET_COVER:
			{
				EditorState.boShowCoverGrid			= TRUE;
				EditorState.boShowWorldGrid			= FALSE;
				EditorState.boShowWorldAttr			= FALSE;
				EditorState.boShowCoverAttr			= TRUE;
				EditorState.boShowCoverRedrawRect   = TRUE;
				EditorState.boShowMap				= TRUE;
				EditorState.boShowCha				= TRUE;
				EditorState.boShowChaRect			= TRUE;
				EditorState.boCharMove				= TRUE;
				strcpy(strEditorTarget , "编辑器 : 遮挡");
				break;
			}
		case EDITOR_TARGET_RUN:
			{
				EditorState.boShowCoverGrid			= FALSE;
				EditorState.boShowWorldGrid			= FALSE;
				EditorState.boShowWorldAttr			= FALSE;
				EditorState.boShowCoverAttr			= FALSE;
				EditorState.boShowCoverRedrawRect   = FALSE;
				EditorState.boShowMap				= TRUE;
				EditorState.boShowCha				= TRUE;
				EditorState.boShowChaRect			= FALSE;
				EditorState.boCharMove				= TRUE;
				strcpy(strEditorTarget , "编辑器 : 测试运行");
				break;
			}

	}


}