waitformeet.cpp

来自「dk1游戏的原代码文件,完整.编译系统redhat7.3,mysql 3.23 」· C++ 代码 · 共 330 行

#include "Assert.h"
#include "Player.h"
#include "GamePlayer.h"
#include "Slayer.h"
#include "Vampire.h"
#include "PacketUtil.h"
#include "PlayerCreature.h"
#include "ItemNameInfo.h"
#include "FlagSet.h"
#include "StringStream.h"
#include "StringPool.h"

#include "WaitForMeet.h"
#include "CoupleManager.h"
#include "OptionInfo.h"
#include "VariableManager.h"

#include "item/CoupleRing.h"
#include "item/VampireCoupleRing.h"
#include "ItemFactoryManager.h"

#include "Gpackets/GCCreateItem.h"
//#include "Gpackets/GCItemNameInfoList.h"
#include "Gpackets/GCNPCResponse.h"
#include "Gpackets/GCSystemMessage.h"
#include "Gpackets/GCModifyInformation.h"

#include <stdio.h>

const int CoupleRingOptionNum = 4;
static const char* CoupleRingOptions[2][4] =
{	{ "STR+4", "DEX+4", "DAM+3", "HP+4" },
	{ "STR+4", "DEX+4", "DAM+3", "ASPD+4" } };

uint WaitForMeet::waitPartner( PlayerCreature* pTargetPC )
	throw(Error)
{
	__BEGIN_TRY

	if ( pTargetPC == NULL )
		return COUPLE_MESSAGE_LOGOFF;		// 傲 捞皋矫瘤 敬促. 喊肺 咯扁辑 府畔登绰 老阑 绝阑淀

	PlayerCreature* pWaitingPC = getWaitingPC();
	if ( pWaitingPC == NULL )
		return COUPLE_MESSAGE_LOGOFF;

	uint result = canMakeCouple( pWaitingPC, pTargetPC );
	if ( result != 0 )
		return result;

	GCSystemMessage gcSystemMessage;
//	StringStream msg;
//	msg << pWaitingPC->getName() << "丛栏肺何磐 目敲 脚没捞 吭嚼聪促.";

	char msg[100];
	sprintf( msg, g_pStringPool->c_str( STRID_REQUEST_MEET ), pWaitingPC->getName().c_str() );
	gcSystemMessage.setMessage( msg );

	pTargetPC->getPlayer()->sendPacket( &gcSystemMessage );

	return 0;
	
	__END_CATCH
}

uint WaitForMeet::acceptPartner( PlayerCreature* pRequestedPC )
	throw(Error)
{
	__BEGIN_TRY

	Assert( pRequestedPC != NULL );

	PlayerCreature* pWaitingPC = getWaitingPC();
	if ( pWaitingPC == NULL )
		return COUPLE_MESSAGE_LOGOFF;

	// 辆练捞 促福芭唱 己喊捞 鞍栏搁 救等促.
	// 饭骇 力茄俊 吧府芭唱 捣捞 葛磊扼档 救等促.
	// 笛 吝 茄疙捞 捞固 目敲捞扼档 救等促.
	uint result = canMakeCouple( pRequestedPC, pWaitingPC );
	if ( result != 0 )
		return result;

	// 目敲傅阑 霖促.
	_TPOINT pt1;
	_TPOINT pt2;

	// 茄疙父 罐绰 版快甫 规瘤窍扁 困秦 固府 持阑 荐 乐绰瘤甫 犬牢茄促.
	// 官蹿俊 冻绢瘤搁 抄府抄促.
	if ( !(canGetCoupleRing( pRequestedPC, pt1 ) && canGetCoupleRing( pWaitingPC, pt2 )) ) return COUPLE_MESSAGE_INVENTORY_FULL;

	// 目敲傅阑 霖促.
	CoupleRingBase* pNewItem1 = giveCoupleRing( pRequestedPC, pWaitingPC->getName(), &pt1 );
	CoupleRingBase* pNewItem2 = giveCoupleRing( pWaitingPC, pRequestedPC->getName(), &pt2 );

	// 困俊辑 犬牢沁栏骨肺 咯扁辑 秽荤府唱搁 胶饭靛啊 部看芭唱 刚 巩力啊 乐促.
	Assert( pNewItem1 != NULL );
	Assert( pNewItem2 != NULL );

	// 目敲傅俊 辑肺 惑措狼 酒捞袍ID甫 扁废秦敌促. 唱吝俊 瘤匡锭 鞍捞 瘤况具 登聪鳖.
	pNewItem1->setPartnerItemID( pNewItem2->getItemID() );
	pNewItem2->setPartnerItemID( pNewItem1->getItemID() );

//	ItemNameInfo *pRequestedPCItemNameInfo = new ItemNameInfo( pNewItem1->getObjectID(), pWaitingPC->getName() );
//	ItemNameInfo *pWaitingPCItemNameInfo = new ItemNameInfo( pNewItem2->getObjectID(), pRequestedPC->getName() );

//	pRequestedPC->addItemNameInfoList( pRequestedPCItemNameInfo );
//	pWaitingPC->addItemNameInfoList( pWaitingPCItemNameInfo );

	// 目敲概聪历俊 殿废茄促.
	g_pCoupleManager->makeCouple( pWaitingPC, pRequestedPC );

	// 目敲 殿废陛阑 罐酒辰促.
	receiveCoupleRegisterFee( pWaitingPC );
	receiveCoupleRegisterFee( pRequestedPC );

	// 捞力 沥侥栏肺 目敲烙阑 急器钦聪促.
	pRequestedPC->getFlagSet()->turnOn( FLAGSET_IS_COUPLE );
	pWaitingPC->getFlagSet()->turnOn( FLAGSET_IS_COUPLE );
	pRequestedPC->getFlagSet()->turnOn( FLAGSET_WAS_COUPLE );
	pWaitingPC->getFlagSet()->turnOn( FLAGSET_WAS_COUPLE );

	pRequestedPC->getFlagSet()->save( pRequestedPC->getName() );
	pWaitingPC->getFlagSet()->save( pWaitingPC->getName() );
	
	// 歹 且 芭 绝唱.....
	// 捞抚嘿篮 酒捞袍 府胶飘 格废阑 盎脚秦辑 焊郴霖促.
	// 救 焊郴霖促. -_- - 2003.2.24
/*	if ( !pRequestedPC->isEmptyItemNameInfoList()
		&& !pWaitingPC->isEmptyItemNameInfoList() )
	{
		GCItemNameInfoList  gcRequestedPCItemNamInfoList;
		GCItemNameInfoList  gcWaitingPCItemNamInfoList;

		makeGCItemNameInfoList( &gcRequestedPCItemNamInfoList, pRequestedPC );
		makeGCItemNameInfoList( &gcWaitingPCItemNamInfoList, pWaitingPC );

		pRequestedPC->getPlayer()->sendPacket( &gcRequestedPCItemNamInfoList );
		pWaitingPC->getPlayer()->sendPacket( &gcWaitingPCItemNamInfoList );
	}
	else 
	{
		Assert(false);
	}*/

	return 0;
	
	__END_CATCH
}

void WaitForMeet::timeExpired()
	throw(Error)
{
	__BEGIN_TRY

	// 扁促府带 荤恩俊霸 救登继嚼聪促..扼绊 皋矫瘤甫 焊郴霖促.
	GCNPCResponse gcNPCResponse;
	gcNPCResponse.setCode( NPC_RESPONSE_MEET_WAIT_TIME_EXPIRED );

	PlayerCreature* pPC = getWaitingPC();
	if ( pPC != NULL )
		pPC->getPlayer()->sendPacket( &gcNPCResponse );
	
	__END_CATCH
}

Gold_t WaitForMeet::getCoupleRegisterFee( PlayerCreature* pPC )
	throw(Error)
{
	__BEGIN_TRY

	Assert( pPC != NULL );

	Gold_t ret = 0;

	switch( pPC->getRace() )
	{
		case RACE_SLAYER:
			{
				Slayer* pSlayer = dynamic_cast<Slayer*>( pPC );
				Assert( pSlayer != NULL );

				ret = 100000 * ( pSlayer->getTotalAttr( ATTR_BASIC ) / 3 );
			}
			break;
		case RACE_VAMPIRE:
			{
				Vampire* pVampire = dynamic_cast<Vampire*>( pPC );
				Assert( pVampire != NULL );

				ret = 100000 * pVampire->getLevel();
			}
			break;
		default:
			return 0;
	}

	return ret;

	__END_CATCH
}

void WaitForMeet::receiveCoupleRegisterFee( PlayerCreature* pPC ) 
	throw(Error)
{ 
	__BEGIN_TRY

	pPC->decreaseGoldEx( getCoupleRegisterFee( pPC ) ); 
	GCModifyInformation gcMI;

	gcMI.addLongData( MODIFY_GOLD, pPC->getGold() );
	pPC->getPlayer()->sendPacket( &gcMI );


	__END_CATCH
}

uint WaitForMeet::canMakeCouple( PlayerCreature* pPC1, PlayerCreature* pPC2 )
{
	if ( pPC1->getRace() != pPC2->getRace() ) return COUPLE_MESSAGE_DIFFERENT_RACE;
	if ( pPC1->getSex() == pPC2->getSex() ) return COUPLE_MESSAGE_SAME_SEX;

	uint result = canHavePartner( pPC1 );
	if ( result != 0 )
		return result;

	result = canHavePartner( pPC2 );
	if ( result != 0 )
		return result;

	return 0;
}

OptionType_t WaitForMeet::getRandomOptionType( PlayerCreature* pPC )
{
	int op = rand() % 4;
	return g_pOptionInfoManager->getOptionType( CoupleRingOptions[(int)pPC->getRace()][op] );
}

CoupleRingBase* WaitForMeet::giveCoupleRing( PlayerCreature* pPC, string partnerName, _TPOINT* pPt )
	throw(Error)
{
	__BEGIN_TRY

	list<OptionType_t> optionList;
	optionList.push_back( getRandomOptionType( pPC ) );
	
	Item* 		pNewItem 		= g_pItemFactoryManager->createItem(getItemClass( pPC ), getItemType( pPC ), optionList);
	CoupleRingBase* pCoupleItem 	= dynamic_cast<CoupleRingBase*>(pNewItem);
	Assert(pCoupleItem != NULL);
	pCoupleItem->setName( partnerName );
	pPC->getZone()->registerObject( pCoupleItem );

	Inventory* pPCInven = pPC->getInventory();

	_TPOINT pt;

	if ( pPt == NULL )
	{
		if ( !canGetCoupleRing( pPC, pt ) ) return NULL;
	}
	else
	{
		pt = *pPt;
	}

	Assert(pPCInven->addItem(pt.x, pt.y, pCoupleItem));
	pCoupleItem->create( pPC->getName(), STORAGE_INVENTORY, 0, pt.x, pt.y );

	GCCreateItem	gcCreateItem;
	makeGCCreateItem( &gcCreateItem, pCoupleItem, pt.x, pt.y );
	pPC->getPlayer()->sendPacket(&gcCreateItem);

	return pCoupleItem;

	__END_CATCH
}

bool WaitForMeet::canGetCoupleRing( PlayerCreature* pPC, _TPOINT& pt )
{
	ItemInfo* pCoupleItemInfo = CoupleRingBase::getItemInfo( getItemType( pPC ), pPC->getRace() );//g_pCoupleItemInfoManager->getItemInfo(0);
	return pPC->getInventory()->getEmptySlot( pCoupleItemInfo->getVolumeWidth(), pCoupleItemInfo->getVolumeHeight(), pt );
}

uint WaitForMeet::canHavePartner( PlayerCreature* pPC )
	throw(Error)
{
	__BEGIN_TRY

	Assert( pPC != NULL );

	GamePlayer* pGP = dynamic_cast<GamePlayer*>(pPC->getPlayer());
	Assert( pGP != NULL );

	if ( !pGP->isPayPlaying() ) return COUPLE_MESSAGE_NOT_PAY_PLAYER;
	if ( pPC->getFlagSet()->isOn( FLAGSET_IS_COUPLE ) ) return COUPLE_MESSAGE_ALREADY_COUPLE;
	if ( !g_pVariableManager->canRecouple() )
		if ( pPC->getFlagSet()->isOn( FLAGSET_WAS_COUPLE ) ) return COUPLE_MESSAGE_WAS_COUPLE;
	if ( pPC->getGold() < getCoupleRegisterFee( pPC ) ) return COUPLE_MESSAGE_NOT_ENOUGH_GOLD;

	switch( pPC->getRace() )
	{
		case RACE_SLAYER:
			{
				Slayer* pSlayer = dynamic_cast<Slayer*>(pPC);
				Assert( pSlayer != NULL );
				Attr_t totalAttr = pSlayer->getTotalAttr( ATTR_BASIC );
				if ( totalAttr < 65 )
					return COUPLE_MESSAGE_NOT_ENOUGH_ATTR;
			}
			break;
		case RACE_VAMPIRE:
			{
				Vampire* pVampire = dynamic_cast<Vampire*>(pPC);
				Assert( pVampire != NULL );
				if ( pVampire->getLevel() < 20 )
					return COUPLE_MESSAGE_NOT_ENOUGH_LEVEL;
			}
			break;

		default:
			Assert( false );
	}

	return 0;

	__END_CATCH
}