tilemanager.cpp

墨香最新私服

	for( int i = 0 ; i <= MaxDelta ; ++i )
	{
		PrevCellX = CellX;
		PrevCellY = CellY;

		x += absDX;  
		y += absDY;
		
		if( x > MaxDelta)  
		{  
			x -= MaxDelta;
			CellX += signDX;
		}
		
		if( y > MaxDelta ) 
		{  
			y -= MaxDelta;  
			CellY += signDY;  
		}
		CFixedTile *pTile = pFixedTile->GetFixedTile(CellX, CellY);
		ASSERT(pTile);
		if(pTile == NULL)
		{
			if(pTarget)
			{
				pTarget->x = PrevCellX*TILECOLLISON_DETAIL;
				pTarget->y = 0;
				pTarget->z = PrevCellY*TILECOLLISON_DETAIL;
			}
			return TRUE;
		}
		if(pTile->IsCollisonTile())
		{
			if(pTarget)
			{
				pTarget->x = PrevCellX*TILECOLLISON_DETAIL;
				pTarget->y = 0;
				pTarget->z = PrevCellY*TILECOLLISON_DETAIL;
			}
			return TRUE;
		}
	}
	if(pTarget)
	{
		pTarget->x = x2*TILECOLLISON_DETAIL;
		pTarget->y = 0;
		pTarget->z = y2*TILECOLLISON_DETAIL;
	}

	return FALSE;
}
BOOL CTileManager::CollisionCheck(VECTOR3* pStart,VECTOR3* pEnd,VECTOR3* pRtCollisonPos, CObject* pObject)
{	
	if( pStart->x >= 51200 || pStart->x < 0 ||
		pStart->z >= 51200 || pStart->z < 0 )
	{
//		ASSERTMSG(0,"捞悼康开阑 哈绢车嚼聪促.");
		pRtCollisonPos->x = 25000;
		pRtCollisonPos->z = 25000;
		return TRUE;
	}

	int x0 = int(pStart->x / TILECOLLISON_DETAIL);
	int y0 = int(pStart->z / TILECOLLISON_DETAIL);
	int x1 = int(pEnd->x / TILECOLLISON_DETAIL);
	int y1 = int(pEnd->z / TILECOLLISON_DETAIL);
	
	int dx = x1-x0,dy = y1-y0;
	int sx,sy;
	if(dx >= 0)
	{
		sx = 1;
	}
	else
	{
		sx = -1;
		dx *= -1;
	}
	if(dy >= 0)
	{
		sy = 1;
	}
	else
	{
		sy = -1;
		dy *= -1;
	}
	
	int ax = 2*dx,ay = 2*dy;

	int x = x0, y = y0;
	int lastx = x, lasty = y;
	
	BOOL bFirst = TRUE;
	if(dx == 0 && dy == 0)
		bFirst = FALSE;
	
	CFixedTileInfo* pFixedTile = GetFixedTileInfo(pObject);

	if(dx >= dy)
	{
		for(int desc = ay - dx; ;x += sx,desc += ay)
		{			
			if(bFirst == TRUE)
			{
				bFirst = FALSE;
				continue;
			}

			CFixedTile *pTile = pFixedTile->GetFixedTile(x, y);
			ASSERT(pTile);
			if(pTile == NULL)
			{
				if(pRtCollisonPos)
				{					
					pRtCollisonPos->x = lastx*TILECOLLISON_DETAIL;
					pRtCollisonPos->y = 0;
					pRtCollisonPos->z = lasty*TILECOLLISON_DETAIL;
				}
				return TRUE;
			}

			if(pTile->IsCollisonTile())
			{
				if(pRtCollisonPos)
				{					
					pRtCollisonPos->x = lastx*TILECOLLISON_DETAIL;
					pRtCollisonPos->y = 0;
					pRtCollisonPos->z = lasty*TILECOLLISON_DETAIL;
				}
				return TRUE;
			}

			if(x == x1)
				break;

			lastx = x;
			lasty = y;

			if(desc > 0)
			{
				y += sy;
				desc -= ax;
			}
		}
	}
	else
	{
		for(int desc = ax - dy; ;y += sy,desc += ax)
		{
			if(bFirst == TRUE)
			{
				bFirst = FALSE;
				continue;
			}

			CFixedTile *pTile = pFixedTile->GetFixedTile(x, y);
			ASSERT(pTile);
			if(pTile == NULL)
			{
				if(pRtCollisonPos)
				{
					pRtCollisonPos->x = lastx*TILECOLLISON_DETAIL;
					pRtCollisonPos->y = 0;
					pRtCollisonPos->z = lasty*TILECOLLISON_DETAIL;
				}
				return TRUE;
			}

			if(pTile->IsCollisonTile())
			{
				if(pRtCollisonPos)
				{
					pRtCollisonPos->x = lastx*TILECOLLISON_DETAIL;
					pRtCollisonPos->y = 0;
					pRtCollisonPos->z = lasty*TILECOLLISON_DETAIL;
				}
				return TRUE;
			}

			if(y == y1)
				break;
			
			lastx = x;
			lasty = y;

			if(desc > 0)
			{
				x += sx;
				desc -= ay;
			}
		}
	}
	return FALSE;
}

/*
BOOL CTileManager::CollisionCheck(VECTOR3* pStart,VECTOR3* pEnd,VECTOR3* pRtCollisonPos)
{
	if( pStart->x >= 51200 || pStart->x < 0 ||
		pStart->z >= 51200 || pStart->z < 0 )
	{
		ASSERTMSG(0,"捞悼康开阑 哈绢车嚼聪促.");
		pRtCollisonPos->x = 25000;
		pRtCollisonPos->z = 25000;
		return TRUE;
	}
	if(	pEnd->x >= 51200 || pEnd->x < 0 ||
		pEnd->z >= 51200 || pEnd->z < 0 )
	{
		if(pRtCollisonPos)
		{
			if(pRtCollisonPos->x < 10)
				pRtCollisonPos->x = 10;
			if(pRtCollisonPos->z < 10)
				pRtCollisonPos->z = 10;
			if(pRtCollisonPos->x > 51200)
				pRtCollisonPos->x = 51200;
			if(pRtCollisonPos->z > 51200)
				pRtCollisonPos->z = 51200;
		}
		return TRUE;
	}

	VECTOR3 nor;
	VECTOR3 curpos = *pStart,lastpos;
	nor = *pEnd - *pStart;
	float dist = GetLength(&nor);
	if(dist != 0)
		nor = nor / dist;

	for(float a = 0.5f; ; a+= TILECOLLISON_DETAIL)
	{
		if(a > dist)
			a = dist;

		lastpos = curpos;
		curpos = nor * a;
		curpos = curpos + *pStart;

		CTile *pTile = GetTile(curpos.x, curpos.z);
		ASSERT(pTile);

		if(pTile->IsCollisonTile())
		{
			if(pRtCollisonPos)
			*pRtCollisonPos = lastpos;
			return TRUE;
		}

		if(a==dist)
			break;
	}

	return FALSE;
}
*/

void CTileManager::AddObject(CObject* pObject)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
		return;
	pTileGroup->AddObject(pObject);

/*	int size = pObject->GetObjectTileSize();
	VECTOR3* pPos = CCharMove::GetPosition(pObject);
	
	TILEINDEX FirstTileIndex = GetTileIndex(pPos->x,pPos->z);
		TILEINDEX CurTileIndex;
	
	pObject->SetPreoccupiedTileIndex(FirstTileIndex);
		
	
	CTile* pTile;
	for(int n=0;n<TM_ObjectRegionNum[size];++n)
	{
		CurTileIndex = FirstTileIndex + m_ppObjectSizeRegion[size][n];
		pTile = pTileGroup->GetTile(&CurTileIndex);
		pTile->IncreasePreoccupied();
	}*/
}

void CTileManager::RemoveObject(CObject* pObject)
{
	if(pObject->GetInitedGrid() == FALSE)
		return;

	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
		return;
	pTileGroup->RemoveObject(pObject);

	/*
	int size = pObject->GetObjectTileSize();
	TILEINDEX FirstTileIndex = pObject->GetPreoccupiedTileIndex();
	TILEINDEX CurTileIndex;
	
	pTileGroup->RemoveObject(size, FirstTileIndex);
	
	CTile* pTile;
		for(int n=0;n<TM_ObjectRegionNum[size];++n)
		{
			CurTileIndex = FirstTileIndex + m_ppObjectSizeRegion[size][n];
			pTile = GetTile(&CurTileIndex);
			pTile->DecreasePreoccupied();
		}*/
}

BOOL CTileManager::IsPreoccupied(CObject* pObject,VECTOR3* pPos)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
		return FALSE;
	return pTileGroup->IsPreoccupied(pObject, pPos);

	/*
	int size = pObject->GetObjectTileSize();
		TILEINDEX FirstTileIndex = GetTileIndex(pPos->x,pPos->z);
		return IsPreoccupied(size,&FirstTileIndex,pObject);*/
}

/*
BOOL CTileManager::IsPreoccupied(int size,TILEINDEX* pCenterTile,CObject* pObject)
{
	BOOL rt = FALSE;
	CTile* pTile;
	TILEINDEX CurTileIndex,ObjectCurTilePos;

	if(pObject)
	{
		ObjectCurTilePos = pObject->GetPreoccupiedTileIndex();
		
		// 磊府甫 癸促啊
		for(int n=0;n<TM_ObjectRegionNum[size];++n)
		{
			CurTileIndex = ObjectCurTilePos + m_ppObjectSizeRegion[size][n];
			pTile = GetTile(&CurTileIndex);	
			pTile->DecreasePreoccupied();
		}
	}

	// 八荤甫 窍绊
	for(int n=0;n<TM_ObjectRegionNum[size];++n)
	{
		CurTileIndex = *pCenterTile + m_ppObjectSizeRegion[size][n];
		pTile = GetTile(&CurTileIndex);	
		if(pTile->GetPreoccupied() > 0 || pTile->IsCollisonTile() == TRUE)
		{
			rt = TRUE;
			break;
		}
	}

	if(pObject)
	{
		// 促矫 盲况持绰促.
		for(int n=0;n<TM_ObjectRegionNum[size];++n)
		{
			CurTileIndex = ObjectCurTilePos + m_ppObjectSizeRegion[size][n];
			pTile = GetTile(&CurTileIndex);	
			pTile->IncreasePreoccupied();
		}
	}
	return rt;
}*/


int CTileManager::GetPreoccupiedNum(CObject* pObject,VECTOR3* pPos)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
		return 0;
	return pTileGroup->GetPreoccupiedNum(pObject, pPos);

	/*
	int size = pObject->GetObjectTileSize();
		TILEINDEX FirstTileIndex = GetTileIndex(pPos->x,pPos->z);
		TILEINDEX CurTileIndex;
	
		int preo = 0;
		CTile* pTile;
		for(int n=0;n<TM_ObjectRegionNum[size];++n)
		{
			CurTileIndex = FirstTileIndex + m_ppObjectSizeRegion[size][n];
			pTile = GetTile(&CurTileIndex);	
			
			if(preo < pTile->GetPreoccupied())
				preo = pTile->GetPreoccupied();
		}
		return preo;*/
	
}

BOOL CTileManager::Preoccupy(CObject* pObject,VECTOR3* pPos)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
		return FALSE;
	return pTileGroup->Preoccupy(pObject, pPos);

/*
	int size = pObject->GetObjectTileSize();
	TILEINDEX LastTileIndex = pObject->GetPreoccupiedTileIndex();
	TILEINDEX ToGoTileIndex = GetTileIndex(pPos->x,pPos->z);
	if(LastTileIndex == ToGoTileIndex)
		return TRUE;
	
	pObject->SetPreoccupiedTileIndex(ToGoTileIndex);

	CTile* pLastTile,*pTogoTile;
	TILEINDEX CurTileIndex;
	for(int n=0;n<TM_ObjectRegionNum[size];++n)
	{
		CurTileIndex = LastTileIndex + m_ppObjectSizeRegion[size][n];
		pLastTile = GetTile(&CurTileIndex);
		CurTileIndex = ToGoTileIndex + m_ppObjectSizeRegion[size][n];
		pTogoTile = GetTile(&CurTileIndex);

		pLastTile->DecreasePreoccupied();
		pTogoTile->IncreasePreoccupied();
	}
	return TRUE;*/
}

VECTOR3 CTileManager::GetNextCloserPos(CObject* pObject,VECTOR3* pTargetPos,VECTOR3* pCurPos,float closestDist,float limitDist)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
	{
		return *pCurPos;
	}
	VECTOR3 pos = pTileGroup->GetNextCloserPos(pObject,pTargetPos,pCurPos,closestDist,limitDist);
	
	ASSERT(!(pos.x == 0 && pos.z == 0));
	
	return pos;
	/*
	int size = pObject->GetObjectTileSize();
		//////////////////////////////////////////////////////////////////////////
		// 规氢 备窍扁
		int dir;
		VECTOR3 vdir =  *pCurPos - *pTargetPos;
		float angle = RADTODEG(VECTORTORAD(vdir));
		angle += 45;
		if(angle >= 360) angle -= 360;
		dir = int(angle / 90);
		ASSERT(dir >= 0 && dir < eDIR_Max);
		
		//////////////////////////////////////////////////////////////////////////	
		TILEINDEX EmptyTile;
		TILEINDEX TargetIndex = GetTileIndex(pTargetPos->x,pTargetPos->z);
	
		for(int n=0;n<MAX_ADDPos;++n)
		{
			EmptyTile = m_AddPos[dir][n] + TargetIndex;
			
			if(m_AddDistance[n] < closestDist)
			{
				continue;
			}
			if(m_AddDistance[n] > limitDist)
			{
				n = MAX_ADDPos - 1;			// 芭府啊 钢搁 弊成 付瘤阜栏肺 逞败滚覆
				EmptyTile = m_AddPos[dir][n] + TargetIndex;
			}
			
			if(IsPreoccupied(size,&EmptyTile) == FALSE)
			{
				break;
			}
		}
		
		//////////////////////////////////////////////////////////////////////////
		// 50cm 鸥老狼 吝居俊 辑霸 茄促.
		float TileWidth = 50;
		VECTOR3 EmptyPos;
		EmptyPos.x = EmptyTile.nx * TileWidth + TileWidth * 0.5f;
		EmptyPos.y = 0;
		EmptyPos.z = EmptyTile.nz * TileWidth + TileWidth * 0.5f;
	
			
		return EmptyPos;*/
}



void CTileManager::AddTileAttrByAreaData(CObject* pObject,VECTOR3* pPos,AREATILE areatile)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
		return;
	pTileGroup->AddTileAttrib(pPos,areatile);
}

void CTileManager::RemoveTileAttrByAreaData(CObject* pObject,VECTOR3* pPos,AREATILE areatile)
{
	CTileGroup* pTileGroup = GetTileGroup(pObject);
	if(pTileGroup == NULL)
		return;
	pTileGroup->RemoveTileAttrib(pPos,areatile);
}