map.cpp

国内著名网络游戏dragon的客户端登陆用完整源码 配套一起上传的服务端部分可开服 无说明文档

		DeleteRoofGroup( lpRoofHeader, lpRoofGroup );
		lpRoofGroup = lpRoofGroupNext;
	}
}

LPROOFGROUP  AddRoofGroup( LPROOFHEADER lpRoofHeader )
{
	LPROOFGROUP		lpRoofGroup;

	if ( ( lpRoofGroup = ( LPROOFGROUP )GlobalAlloc( GPTR, sizeof( ROOFGROUP ) ) ) == ( LPROOFGROUP )NULL )
	{
		return	NULL;
	}

	if ( lpRoofHeader->lpLast == NULL )
	{
		lpRoofGroup->lpPrev = lpRoofGroup->lpNext = NULL;
		lpRoofHeader->lpFirst = lpRoofHeader->lpLast = lpRoofGroup;
	}
	else
	{
		lpRoofGroup->lpPrev = lpRoofHeader->lpLast;
		lpRoofGroup->lpNext = NULL;

		lpRoofHeader->lpLast->lpNext = lpRoofGroup;
		lpRoofHeader->lpLast = lpRoofGroup;
	}
	lpRoofHeader->count++;

	return	lpRoofGroup;
}

void
DeleteRoofGroup( LPROOFHEADER lpRoofHeader, LPROOFGROUP lpRoofGroup )
{
	if ( lpRoofGroup != NULL )
	{
		LPROOF		lpRoof, lpRoofNext;
		
		lpRoof = lpRoofNext = lpRoofGroup->lpFirst;
		while( lpRoof )
		{
			lpRoofNext = lpRoof->lpNext;
			DeleteRoof( lpRoofGroup, lpRoof );
			lpRoof = lpRoofNext;
		}

		if ( lpRoofGroup->lpPrev != NULL )
		{
			lpRoofGroup->lpPrev->lpNext = lpRoofGroup->lpNext;
		}
		if ( lpRoofGroup->lpNext != NULL )
		{
			lpRoofGroup->lpNext->lpPrev = lpRoofGroup->lpPrev;
		}

		if ( lpRoofHeader->lpLast == lpRoofGroup )
		{
			lpRoofHeader->lpLast = lpRoofGroup->lpPrev;
		}
		if ( lpRoofHeader->lpFirst == lpRoofGroup )
		{
			lpRoofHeader->lpFirst = lpRoofGroup->lpNext;
		}

		lpRoofHeader->count--;

		GlobalFree( lpRoofGroup );
		lpRoofGroup = NULL;
	}
}

LPROOF
AddRoof( LPROOFGROUP lpRoofGroup, WORD x, WORD y )
{
	LPROOF		lpRoof;

	if ( ( lpRoof = ( LPROOF )GlobalAlloc( GPTR, sizeof( ROOF ) ) ) == ( LPROOF )NULL )
	{
		return	NULL;
	}

	lpRoof->x = x;
	lpRoof->y = y;

	if ( lpRoofGroup->lpLast == NULL )
	{
		lpRoof->lpPrev = lpRoof->lpNext = NULL;
		lpRoofGroup->lpFirst = lpRoofGroup->lpLast = lpRoof;
	}
	else
	{
		lpRoof->lpPrev = lpRoofGroup->lpLast;
		lpRoof->lpNext = NULL;

		lpRoofGroup->lpLast->lpNext = lpRoof;
		lpRoofGroup->lpLast = lpRoof;
	}
	lpRoofGroup->count++;

	return	lpRoof;
}

void
DeleteRoof( LPROOFGROUP lpRoofGroup, LPROOF lpRoof )
{
	if ( lpRoof != NULL )
	{
		if ( lpRoof->lpPrev != NULL )
		{
			lpRoof->lpPrev->lpNext = lpRoof->lpNext;
		}
		if ( lpRoof->lpNext != NULL )
		{
			lpRoof->lpNext->lpPrev = lpRoof->lpPrev;
		}

		if ( lpRoofGroup->lpLast == lpRoof )
		{
			lpRoofGroup->lpLast = lpRoof->lpPrev;
		}
		if ( lpRoofGroup->lpFirst == lpRoof )
		{
			lpRoofGroup->lpFirst = lpRoof->lpNext;
		}

		lpRoofGroup->count--;

		GlobalFree( lpRoof );
		lpRoof = NULL;
	}
}

LPROOFGROUP
FindRoofGroup( LPROOFHEADER lpRoofHeader, WORD index )
{
	LPROOFGROUP		lpRoofGroup = lpRoofHeader->lpFirst;
	int				nCount = 0;

	while ( lpRoofGroup )
	{
		if ( nCount++ == index )
		{
			return	lpRoofGroup;
		}

		lpRoofGroup = lpRoofGroup->lpNext;
	}

	return	NULL;
}

LPROOF
FindRoof( LPROOFGROUP lpRoofGroup, WORD x, WORD y )
{
	LPROOF		lpRoof = lpRoofGroup->lpFirst;

	while ( lpRoof )
	{
		if ( lpRoof->x == x && lpRoof->y == y )
		{
			return	lpRoof;
		}

		lpRoof = lpRoof->lpNext;
	}

	return	NULL;
}

BOOL
ReadRoofData( LPROOFHEADER lpRoofHeader, char* lpszFileName )
{
	FILE *fp;
	WORD	headercount, groupcount;
	WORD	x, y;

	fp = Fopen( lpszFileName, "rb" );
	{
		fread( &headercount, sizeof( headercount ), 1, fp );
		for ( int i = 0; i < headercount; i++ )
		{
			fread( &groupcount, sizeof( groupcount ), 1, fp );

			AddRoofGroup( lpRoofHeader );

			for ( int j = 0; j < groupcount; j++ )
			{
				fread( &x, sizeof( x ), 1, fp );
				fread( &y, sizeof( y ), 1, fp );

				AddRoof( lpRoofHeader->lpLast, x, y );
			}
		}

		fclose( fp );
		return	TRUE;
	}

	return	FALSE;
}

///////////////////////////////////////////////////////////////////////////////
// event

BOOL
BuildEventList( char* mapname )
{
	char szFileName[ FILENAME_MAX];

	wsprintf( szFileName, "%s/event/%s.ent", GetCurrentWorkingDirectory( ), MapName );
	g_EventListHeaderMap.lpFirst = g_EventListHeaderMap.lpLast = NULL;
	g_EventListHeaderMap.wCount = 0;

	g_EventListHeaderRoom.lpFirst = g_EventListHeaderRoom.lpLast = NULL;
	g_EventListHeaderRoom.wCount = 0;

	g_EventListHeaderMusic.lpFirst = g_EventListHeaderMusic.lpLast = NULL;
	g_EventListHeaderMusic.wCount = 0;

	if ( !ReadEventList( szFileName ) )
	{
		return	FALSE;
	}
	
	return	TRUE;
}	
	
void
DestroyEventListSub( LPEVENTLISTHEADER lpEventListHeader )
{	
	LPEVENTLIST		lpEventList, lpEventListNext;
	
	lpEventList = lpEventListNext = lpEventListHeader->lpFirst;
	while ( lpEventList )
	{
		lpEventListNext = lpEventList->lpNext;
		DeleteEventList( lpEventListHeader, lpEventList );
		lpEventList = lpEventListNext;
	}
}	
	
	
	
void DestroyEventList( void )
{	
	DestroyEventListSub( &g_EventListHeaderMap );
	DestroyEventListSub( &g_EventListHeaderRoom );
	DestroyEventListSub( &g_EventListHeaderMusic);
	
}	
	
	
LPEVENTLIST
AddEventList( LPEVENTLISTHEADER lpEventListHeader, WORD x, WORD y, WORD wIndex )
{	
	LPEVENTLIST		lpEventList;
	
	if ( ( lpEventList = ( LPEVENTLIST )GlobalAlloc( GPTR, sizeof( EVENTLIST ) ) ) == ( LPEVENTLIST )NULL )
	{
		return	NULL;
	}
	
	if ( lpEventListHeader->lpLast == NULL )
	{
		lpEventList->lpPrev = lpEventList->lpNext = NULL;
		lpEventListHeader->lpFirst = lpEventListHeader->lpLast = lpEventList;
	}
	else
	{
		lpEventList->lpPrev = lpEventListHeader->lpLast;
		lpEventList->lpNext = NULL;
		lpEventListHeader->lpLast->lpNext = lpEventList;
		lpEventListHeader->lpLast = lpEventList;
	}
	lpEventListHeader->wCount++;
	
	lpEventList->x = x;
	lpEventList->y = y;
	lpEventList->index = wIndex;
	
	return	lpEventList;
}	
	
void
DeleteEventList( LPEVENTLISTHEADER lpEventListHeader, LPEVENTLIST lpEventList )
{	
	if ( lpEventList != NULL )
	{
		if ( lpEventList->lpPrev != NULL )
		{
			lpEventList->lpPrev->lpNext = lpEventList->lpNext;
		}
		if ( lpEventList->lpNext != NULL )
		{
			lpEventList->lpNext->lpPrev = lpEventList->lpPrev;
		}
	
		if ( lpEventListHeader->lpFirst == lpEventList )
		{
			lpEventListHeader->lpFirst = lpEventList->lpNext;
		}
		if ( lpEventListHeader->lpLast == lpEventList )
		{
			lpEventListHeader->lpLast = lpEventList->lpPrev;
		}
	
		lpEventListHeader->wCount--;
	
		GlobalFree( lpEventList );
		lpEventList = NULL;
	}
}	
	
LPEVENTLIST
FindEventList( LPEVENTLISTHEADER lpEventListHeader, WORD x, WORD y )
{	
	LPEVENTLIST		lpEventList = lpEventListHeader->lpFirst;
	
	while ( lpEventList )
	{
		if ( lpEventList->x == x && lpEventList->y == y )
		{
			return	lpEventList;
		}
	
		lpEventList = lpEventList->lpNext;
	}
	
	return	NULL;
}	
	
BOOL
ReadEventList( char* lpszFileName )
{		
	FILE	*fp;
	WORD	count;
	WORD	x, y;
	WORD	index;
	int		i;
		
	fp = Fopen( lpszFileName, "rb" );
	if( fp )
	{	
		fread( &count, sizeof( WORD ), 1, fp );
		for ( i = 0; i < count; i++ )
		{
			fread( &x, sizeof( WORD ) , 1, fp);
			fread( &y, sizeof( WORD ) , 1, fp);
			fread( &index, sizeof( WORD ) , 1, fp);
		
			AddEventList( &g_EventListHeaderMap, x, y, index );
		}
		
		fread( &count, sizeof( WORD ), 1,fp );
		for ( i = 0; i < count; i++ )
		{
			fread( &x, sizeof( WORD ) , 1, fp);
			fread( &y, sizeof( WORD ) , 1, fp);
			fread( &index, sizeof( WORD ) , 1, fp);
		
			AddEventList( &g_EventListHeaderRoom, x, y, index );
		}
		
		fread( &count, sizeof( WORD ), 1, fp);
		for ( i = 0; i < count; i++ )
		{
			fread( &x, sizeof( WORD ), 1, fp);
			fread( &y, sizeof( WORD ), 1, fp);
			fread( &index, sizeof( WORD ), 1, fp);
		
			AddEventList( &g_EventListHeaderMusic, x, y, index );
		}
		
		fclose( fp );
		return	TRUE;
	}		
		
	return	FALSE;
}			
	
	
	
	
	
	
	
// ---------------------------------------付快胶俊 狼茄 Map Scroll...
	
	
BOOL IsScreenArea_( POINT position )
{	
	return	PtInRect( &g_GameInfo.rectScreen, position );
}	

BOOL IsScreenArea( LPCHARACTER ch )
{	
	Spr *sp = ch->sp;
	DWORD	mx = ch->position.x;
	DWORD	my = ch->position.y;
	
  if (ch->sprno==50||ch->sprno==51||ch->sprno==52)	// LTS DRAGON BUG
	{
		ch->direction=DIRECTION_DOWN;
		sp=ch->sp=&CharSpr[ ch->sprno ].sp[ ch->direction ][ch->nCurrentFrame];
	}

	if( sp == NULL ) return 0;

	if( mx < 0 ) return 0;
	if( my < 0 ) return 0;
	if( mx > g_Map.file.wWidth  ) return 0;
	if( my > g_Map.file.wHeight ) return 0;
	
	if( g_Inside != TileMap[ mx ][ my ].attr_inside ) return 0;

	int t0 =	BoxAndBoxCrash(	Mapx, Mapy, GAME_SCREEN_XSIZE, GAME_SCREEN_YSIZE, ch->x - sp->ox, ch->y - sp->oy-ch->height, sp->xl, sp->yl );
	int t1 =	BoxAndBoxCrash(	Mapx, Mapy, GAME_SCREEN_XSIZE, GAME_SCREEN_YSIZE, ch->x - sp->ox, ch->y - sp->oy, sp->xl, sp->yl );

	if( t0 || t1 ) return 1;
	
	return 0;
}		

BOOL IsScreenAreaMapObject( int x, int y, SIZE size )
{	
	int xl =  size.cx;
	int yl =  size.cy;
	
	if( BoxAndBoxCrash(	Mapx, Mapy, GAME_SCREEN_XSIZE, GAME_SCREEN_YSIZE, 	x, y, xl, yl ) ) return 1;
	
	return 0;
}	

BOOL IsScreenAreaCSP( int x, int y, Spr *sp )
{	
	int xl = sp->xl;
	int yl = sp->yl;
	if( BoxAndBoxCrash(	Mapx, Mapy, GAME_SCREEN_XSIZE, GAME_SCREEN_YSIZE, x-sp->ox, y-sp->oy, xl, yl ) ) return 1;
	return 0;
}

///////////////////////////// 0808 lkh 眠啊 ////////////////////////////////////
BOOL IsScreenAreaView( int x, int y )		//坷宏璃飘狼 吝痢 谅钎
{
	if( BoxAndDotCrash(	Hero->x-(OBJECTSOUNDPLAY_XSIZE/2), Hero->y-(OBJECTSOUNDPLAY_YSIZE/2), OBJECTSOUNDPLAY_XSIZE, OBJECTSOUNDPLAY_YSIZE, x, y) ) return 1;
	return 0;
}
	
///////////////////////// 0625 lkh 荐沥 /////////////////////////////
void SetView( LPCHARACTER ch, int range )
{	
	int mx,  my;
		
	ch->sight = range;

	int rangex = range;
	int rangey = range-2;
		
	mx = ch->position.x - (GAME_SCREEN_XSIZE/32/2)-1;		//10
	my = ch->position.y - (GAME_SCREEN_YSIZE/32/2)-1;		//7
	
	if( g_Map.x < g_Map.tox ) g_Map.x ++;
	if( g_Map.x > g_Map.tox ) g_Map.x --;
	if( g_Map.y < g_Map.toy ) g_Map.y ++;
	if( g_Map.y > g_Map.toy ) g_Map.y --;

////////////////////////
////////////////////////

	if( g_Map.x < 0 ) g_Map.x = 0;
	if( g_Map.y < 0 ) g_Map.y = 0;

	
	LimitMapSx = mx - rangex+1;	if( LimitMapSx  < 0 ) LimitMapSx = 0;
	LimitMapSy = my - rangey+1;	if( LimitMapSy  < 0 ) LimitMapSy = 0;
	LimitMapEx = mx + rangex;	if( LimitMapEx  > g_Map.file.wWidth  - (GAME_SCREEN_XSIZE/32) )  LimitMapEx = g_Map.file.wWidth  - (GAME_SCREEN_XSIZE/32) ;
	LimitMapEy = my + rangey;	if( LimitMapEy  > g_Map.file.wHeight - (GAME_SCREEN_YSIZE/32)-1 )  LimitMapEy = g_Map.file.wHeight - (GAME_SCREEN_YSIZE/32) -1;
	
	if( g_Map.tox < LimitMapSx ) g_Map.tox = LimitMapSx;
	if( g_Map.tox > LimitMapEx ) g_Map.tox = LimitMapEx;
	
	if( g_Map.toy < LimitMapSy ) g_Map.toy = LimitMapSy;
	if( g_Map.toy > LimitMapEy ) g_Map.toy = LimitMapEy;
}	



// 皋春啊 哆搁 弊俊 蝶扼 墨皋扼狼 秒摹甫 汲沥茄促. 	
//////////////////////////////// 0625 lkh 荐沥 ////////////////////////////////////
// 皋春啊 哆搁 弊俊 蝶扼 墨皋扼狼 秒摹甫 汲沥茄促. 	
void SetHeroPosition( int flag )		// 0110
{	
	int lc = 0, rc = 0;
	int guild=0;
	static WORD changed;
	WORD t = 0;

	int sm[] = {	// 0626_2 YGI
		MN_BLACKSMITH, MN_BLACKSMITH, MN_FARM, MN_RESTAURANT, MN_HERBSHOP, MN_SHAMBLES, MN_CANDLE, MN_SLOPSHOP, 
		MN_ALCHEMY, MN_WOODWORKING, MN_BOWCRAFT, MN_SHIPYARD, MN_SHOP_MAIN, MN_DRINK_MAIN, MN_INN_MAIN, 
		MN_MAGIC_GUILD, MN_ACADEMY, MN_TOWNHALL ,MN_HEAL_MAIN,MN_SKILLGUILD_SKILL, MN_SKILLGUILD_KNOWLAGE, 
		MN_SKILLGUILD_ITEM, MN_MAIL_WRITE,
		MN_MAIL_MENU, MN_MAIL_READ, MN_BANK_DEPOSIT, MN_BANK_DEFRAYAL, MN_BANK_MAIN, MN_BANK_LOAN,
		MN_BANK_REPAYMENT, MN_BANK_AUCTION, MN_BANK_AUCTION_SALE, MN_DRINK_RUMOR, MN_HEAL_HEALING, 
		MN_HEAL_PREVENTING, MN_HEAL_LEARN, MN_INN_REST, MN_INN_SLEEP,
	};
	int sm_max = sizeof( sm ) / sizeof( int);


	if( Hero == NULL ) return;



	t |= ( SMenu[ MN_ITEM           ].bActive ) <<  0;
	t |= ( SMenu[ MN_ARIGEMENT		].bActive ==TRUE ) <<  7;
	t |= ( SMenu[ MN_ABILITY		].bActive ==TRUE ) <<  8;
	t |= ( SMenu[ MN_STATUS			].bActive ==TRUE ) <<  9;