tilemanager.cpp

墨香最新私服

// TileManager.cpp: implementation of the CTileManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TileManager.h"
#include "Tile.h"
#include "FixedTile.h"
#include "FixedTileInfo.h"
#include "TileGroup.h"
#include "MHFile.h"
#include "Battle.h"
#include "Object.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

/*

int TM_AddPos[MAX_ADDPos*3] = {
	0, 0,

	0, -1,
	1, -1,
	-1, -1,

	0, -2,
	1, -2,
	-1, -2,
	2, -2,
	-2, -2,

	0, -3,
	1, -3,
	-1, -3,
	2, -3,
	-2, -3,
	3, -3,
	-3, -3,
	
	0, -4,
	1, -4,
	-1, -4,
	2, -4,
	-2, -4,
	3, -4,
	-3, -4,
	4, -4,
	-4, -4,

	12, 0,
};

int TM_ObjectRegionNum[] = {
	1,	5,	13,	
};

int TM_ObjectSizeTiles[] = {
	0, 0,

	1, 0,
	-1, 0,
	0, 1,
	0, -1,

	2, 0,
	1, 1,
	0, 2,
	-1, 1,
	-2, 0,
	-1, -1,
	0, -2,
	1, -1,
};

*/

CTileManager::CTileManager()
{
	//////////////////////////////////////////////////////////////////////////
	// test	
	{
		VECTOR3 vdir;
		SetVector3(&vdir,0,0,0);		// ???  => 90
		float angle = RADTODEG(VECTORTORAD(vdir));
		angle = angle;
	}
	{
		VECTOR3 vdir;
		SetVector3(&vdir,0,0,-1);		// 0
		float angle = RADTODEG(VECTORTORAD(vdir));
		angle = angle;
	}
	{
		VECTOR3 vdir;
		SetVector3(&vdir,1,0,0);		// 90
		float angle = RADTODEG(VECTORTORAD(vdir));
		angle = angle;
	}
	{
		VECTOR3 vdir;
		SetVector3(&vdir,0,0,1);		// 180
		float angle = RADTODEG(VECTORTORAD(vdir));
		angle = angle;
	}
	{
		VECTOR3 vdir;
		SetVector3(&vdir,-1,0,0);		// 270
		float angle = RADTODEG(VECTORTORAD(vdir));
		angle = angle;
	}


	m_TileGroupTable.Initialize(10);
	m_FixedTileInfoTable.Initialize(10);

/*	m_pTile = NULL;


		float angle;
		TILEINDEX temp;
		for(int n=0;n<eDIR_Max;++n)
		{
			angle = DEGTORAD(90 * n);
			
			for(int i=0;i<MAX_ADDPos;++i)
			{
				temp.nx = TM_AddPos[2*i + 0];
				temp.nz = TM_AddPos[2*i + 1];
	
				float fx,fz;
				fx = temp.nx*cosf(angle) - temp.nz*sinf(angle);
				fz = temp.nx*sinf(angle) + temp.nz*cosf(angle);
				// float 拌魂 坷瞒锭巩俊
				m_AddPos[n][i].nx = int(fx + (fx>0?0.1f:-0.1f));
				m_AddPos[n][i].nz = int(fz + (fz>0?0.1f:-0.1f));
	
				m_AddDistance[i] = sqrtf(float(temp.nx*temp.nx + temp.nz*temp.nz)) * fTILE_SIZE;
			}
		}
	
		m_ppObjectSizeRegion = new TILEINDEX*[MAX_ObjectSize];
		for(n=0;n<MAX_ObjectSize;++n)
		{
			m_ppObjectSizeRegion[n] = new TILEINDEX[TM_ObjectRegionNum[n]];
			for(int t=0;t<TM_ObjectRegionNum[n];++t)
			{
				m_ppObjectSizeRegion[n][t].nx = TM_ObjectSizeTiles[2*t + 0];
				m_ppObjectSizeRegion[n][t].nz = TM_ObjectSizeTiles[2*t + 1];
			}
		}*/
	
}

CTileManager::~CTileManager()
{
/*	SAFE_DELETE_ARRAY(m_pTile);
	for(int n=0;n<MAX_ObjectSize;++n)
	{
		delete [] m_ppObjectSizeRegion[n];
	}
	delete [] m_ppObjectSizeRegion;
*/
	void* pInfo; 
	m_TileGroupTable.SetPositionHead();
	while(pInfo = m_TileGroupTable.GetData())
	{
		delete	pInfo;
	}
	m_TileGroupTable.RemoveAll();

	m_FixedTileInfoTable.SetPositionHead();
	while(pInfo = m_FixedTileInfoTable.GetData())
	{
		delete pInfo;
	}
	m_FixedTileInfoTable.RemoveAll();
}
/*

TILEINDEX CTileManager::GetTileIndex(float fx, float fz)
{
	TILEINDEX rt;
	rt.nz = int(fz / fTILE_SIZE);
	rt.nx = int(fx / fTILE_SIZE);

	if( rt.nx > m_nTileWidth || 
		rt.nz > m_nTileHeight ||
		rt.nx < 0 || rt.nz < 0 )
	{
		//ASSERTMSG(0,"谅钎啊 捞惑钦聪促[CTileManager]");
		rt.nx = 0;
		rt.nz = 0;
		return rt;
	}

	return rt;
}*/


/*
CTile* CTileManager::GetTile(TILEINDEX* pIndex)
{
	return &m_pTile[pIndex->nz * m_nTileWidth + pIndex->nx];
}

CTile* CTileManager::GetTile(float fx, float fz)
{

	if(!(fx >= 0 && fz >= 0))
		return NULL;

	return GetTile(&GetTileIndex(fx,fz));

}

CTile* CTileManager::GetTile(int x, int z)
{
	return &m_pTile[z * m_nTileWidth + x];
}
*/

BOOL CTileManager::LoadFixedTileInfo(MAPTYPE MapNum, char* pMapFile)
{	
	CMHFile file;
	char filename[256];
#ifdef _FILE_BIN_
	sprintf(filename, "MurimMapInfo%d.txt", MapNum);
#else
	sprintf(filename, "MurimMapInfo%d.txt", MapNum);
#endif
	if(file.Init(filename, "r", 1) == FALSE)
	{
		ReadMapFile(MapNum, pMapFile);
		return TRUE;
	}

	
	else
	{
		char Mapfile[64];
		while(1)
		{
			if(file.IsEOF() != FALSE)
				break;
			
			MapNum = file.GetWord();
			strcpy(Mapfile, g_pServerSystem->GetMap()->GetTileName(MapNum));
			ReadMapFile(MapNum, Mapfile);			
		}
	}
	
	file.Release();

/*	hFile = CreateFile(TileFile,GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	if(hFile == INVALID_HANDLE_VALUE)
	{
		m_nTileWidth = m_nTileHeight = 1024;
		m_pTile = new CTile[ m_nTileWidth * m_nTileHeight ];
		
		CTile *pTile;
		TILE_ATTR Attr;
		Attr.uFixedAttr = 0;
		for(int i=0; i< (m_nTileHeight * m_nTileWidth); i++)
		{
			pTile = m_pTile + i;			
			pTile->InitTileAttrib(Attr);
		}
		
		return FALSE;
	}


	//加己颇老 庆歹 佬绢靛覆...
	bResult = ReadFile(hFile, &m_nTileWidth, sizeof(m_nTileWidth), &dwRead, NULL);
	ASSERT(bResult);
	bResult = ReadFile(hFile, &m_nTileHeight, sizeof(m_nTileHeight), &dwRead, NULL);
	ASSERT(bResult);
	
	m_pTile = new CTile[ m_nTileWidth * m_nTileHeight ];

	//加己 沥焊 佬绢靛覆 
	CTile *pTile;
	TILE_ATTR Attr;
	for(int i=0; i< (m_nTileHeight * m_nTileWidth); i++)
	{
		pTile = m_pTile + i;
		bResult = ReadFile(hFile, &Attr , sizeof(FIXEDATTR), &dwRead, NULL);
				
		ASSERT(bResult);		
		ASSERT(!(bResult && dwRead == 0 ));

		pTile->InitTileAttrib(Attr);
	}

	CloseHandle(hFile);
*/
	return TRUE; 
}

void CTileManager::ReadMapFile(MAPTYPE MapNum, char* filename)
{
	HANDLE	hFile = NULL;
	DWORD dwRead = 0;
	BYTE bResult = 0;

	int nTileWidth;
	int nTileHeight;

	hFile = CreateFile(filename,GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if(hFile == INVALID_HANDLE_VALUE)
	{
		nTileWidth = nTileHeight = 1024;
		CFixedTileInfo* pFixedTileInfo = new CFixedTileInfo;
		pFixedTileInfo->Init(nTileWidth, nTileHeight);
		
		CFixedTile *pTile;
		FIXEDTILE_ATTR Attr;
		Attr.uFixedAttr = 0;
		for(int i=0; i< (nTileHeight * nTileWidth); i++)
		{
			pTile = pFixedTileInfo->GetFixedTile() + i;
			pTile->InitTileAttrib(Attr);
		}
		
		CloseHandle(hFile);
		m_FixedTileInfoTable.Add(pFixedTileInfo, MapNum);
		return;
	}
	
	//加己颇老 庆歹 佬绢靛覆...
	bResult = ReadFile(hFile, &nTileWidth, sizeof(nTileWidth), &dwRead, NULL);
	ASSERT(bResult);
	bResult = ReadFile(hFile, &nTileHeight, sizeof(nTileHeight), &dwRead, NULL);
	ASSERT(bResult);
	
	CFixedTileInfo* pFixedTileInfo = new CFixedTileInfo;
	pFixedTileInfo->Init(nTileWidth, nTileHeight);
	//加己 沥焊 佬绢靛覆 
	CFixedTile *pTile;
	FIXEDTILE_ATTR Attr;
	for(int i=0; i< (nTileHeight * nTileWidth); i++)
	{
		pTile = pFixedTileInfo->GetFixedTile() + i;
		bResult = ReadFile(hFile, &Attr , sizeof(FIXEDATTR), &dwRead, NULL);
		
		ASSERT(bResult);		
		ASSERT(!(bResult && dwRead == 0 ));
		
		pTile->InitTileAttrib(Attr);
	}
	
	CloseHandle(hFile);
	m_FixedTileInfoTable.Add(pFixedTileInfo, MapNum);
}

BOOL CTileManager::CreateTileGroup(DWORD TileGroupID, MAPTYPE MapNum, float fStartX, float fStartZ, float fWidth, float fHeight)
{
	CFixedTileInfo* pFixedTileInfo = GetFixedTileInfo(MapNum);
	if(!pFixedTileInfo)
	{
		ASSERT(0);
		return FALSE;
	}

	CTileGroup* pInfo;
	pInfo = new CTileGroup;
	pInfo->Init(pFixedTileInfo, TileGroupID, MapNum, fStartX, fStartZ, fWidth, fHeight);
	m_TileGroupTable.Add(pInfo, TileGroupID);
	
	return TRUE;
}

void CTileManager::DeleteTileGroup(DWORD TileGroupID)
{
	CTileGroup* pTileGroup = GetTileGroup(TileGroupID);
	ASSERT(pTileGroup);
	//鸥老 瘤匡锭 录备录备
	m_TileGroupTable.Remove(TileGroupID);
	delete pTileGroup;
}
CTileGroup* CTileManager::GetTileGroup(CObject* pObject)
{
	DWORD TGID = pObject->GetGridID();

	CTileGroup* pInfo = m_TileGroupTable.GetData(TGID);
//	ASSERT(pInfo);

	// 烙矫
	if(pInfo == NULL)
		pInfo = m_TileGroupTable.GetData((DWORD)0);

	return pInfo;
}
CTileGroup* CTileManager::GetTileGroup(DWORD TileGroupID)
{
	CTileGroup* pInfo = m_TileGroupTable.GetData(TileGroupID);
//	ASSERT(pInfo);
	
	// 烙矫
	if(pInfo == NULL)
		pInfo = m_TileGroupTable.GetData((DWORD)0);

	return pInfo;
}

CFixedTileInfo* CTileManager::GetFixedTileInfo(MAPTYPE MapNum)
{
	CFixedTileInfo* pInfo = m_FixedTileInfoTable.GetData(MapNum);

	if(pInfo == NULL)
	{			
		char filename[256];
		sprintf(filename,"resource/%d.ttb",MapNum);
		LoadFixedTileInfo(MapNum,filename);
	}

	pInfo = m_FixedTileInfoTable.GetData(MapNum);

	ASSERT(pInfo);
	return pInfo;
}
CFixedTileInfo* CTileManager::GetFixedTileInfo(CObject* pObject)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
	{
		m_FixedTileInfoTable.SetPositionHead();
		return m_FixedTileInfoTable.GetData();
	}
	
	ASSERT(pTileGroup);
	CFixedTileInfo* pInfo = pTileGroup->GetFixedTileInfo();
	ASSERT(pInfo);
	return pInfo;
}

int CTileManager::GetTileWidth(MAPTYPE MapNum)
{
	CFixedTileInfo* pInfo = GetFixedTileInfo(MapNum);
	return pInfo->GetTileWidth();
}
BOOL CTileManager::IsInTile(int cellX, int cellY, CObject* pObject)
{
	CFixedTileInfo* pInfo = GetFixedTileInfo(pObject);
	return pInfo->IsInTile(cellX, cellY);
}
BOOL CTileManager::CollisionTileWithTileIndex( int x, int y, CObject* pObject)
{ 
	CFixedTileInfo* pInfo = GetFixedTileInfo(pObject);
	CFixedTile *pTile = pInfo->GetFixedTile(x, y);
	if(pTile == NULL)
		return TRUE;
	return pTile->IsCollisonTile();
}
BOOL CTileManager::CollisionTileWithTileIndex( int x, int y, MAPTYPE MapNum)
{
	CFixedTileInfo* pInfo = GetFixedTileInfo(MapNum);
	CFixedTile *pTile = pInfo->GetFixedTile(x, y);
	if(pTile == NULL)
		return TRUE;
	return pTile->IsCollisonTile();	
}
BOOL CTileManager::CollisionTileWithPosition( float fx, float fy, CObject* pObject)
{ 
	int x = int(fx / TILECOLLISON_DETAIL);
	int y = int(fy / TILECOLLISON_DETAIL);
	return CollisionTileWithTileIndex(x,y,pObject);
}
BOOL CTileManager::CollisionTileWithPosition( float fx, float fy, MAPTYPE MapNum)
{
	int x = int(fx / TILECOLLISON_DETAIL);
	int y = int(fy / TILECOLLISON_DETAIL);
	return CollisionTileWithTileIndex(x,y,MapNum);
}
BOOL CTileManager::CollisionLine(VECTOR3* pSrc,VECTOR3* pDest, VECTOR3 * pTarget, CObject* pObject)
{
	int x1 = int(pSrc->x / TILECOLLISON_DETAIL);
	int y1 = int(pSrc->z / TILECOLLISON_DETAIL);
	int x2 = int(pDest->x / TILECOLLISON_DETAIL);
	int y2 = int(pDest->z / TILECOLLISON_DETAIL);

	int dx = x2 - x1;
	int dy = y2 - y1;
	
	int absDX = abs(dx);
	int absDY = abs(dy);
	int MaxDelta = max(absDX, absDY);
	
	int CellX = x1;
	int CellY = y1;
	int x = 0;
	int y = 0;
	CFixedTileInfo* pFixedTile = GetFixedTileInfo(pObject);

	int signDX = sign(dx);
	int signDY = sign(dy);

	int PrevCellX = 0;
	int PrevCellY = 0;