npc.cpp

魔域源代码需要的可以学习一下真么这么麻烦啊

	case	STATUS_FREEZE:
		{
			m_i64Effect &= ~KEEPEFFECT_FREEZE;
		}
		break;
	case	STATUS_SMOKE:
		{
			m_i64Effect &= ~KEEPEFFECT_SMOKE;
		}
		break;
	case	STATUS_DARKNESS:
		{
			m_i64Effect &= ~KEEPEFFECT_DARKNESS;
		}
		break;
	case	STATUS_PALSY:
		{
			m_i64Effect &= ~KEEPEFFECT_PALSY;
		}
		break;
	case	STATUS_ATTACK:
		{
			m_i64Effect	&= ~KEEPEFFECT_ATTACK;
		}
		break;
	case	STATUS_MAGICDEFENCE:
		{
			m_i64Effect	&= ~KEEPEFFECT_MAGICDEFENCE;
		}
		break;
	case	STATUS_REFLECT:
		{
			m_i64Effect	&= ~KEEPEFFECT_REFLECT;
		}
		break;
	case	STATUS_REFLECTMAGIC:
		{
			m_i64Effect	&= ~KEEPEFFECT_REFLECTMAGIC;
		}
		break;
	case	STATUS_MAGICDAMAGE:
		{
			m_i64Effect	&= ~KEEPEFFECT_MAGICDAMAGE;
		}
		break;
	case	STATUS_ATKSPEED:
		{
			m_i64Effect	&= ~KEEPEFFECT_ATKSPEED;
		}
		break;
	case	STATUS_LURKER:
		{
			m_i64Effect	&= ~KEEPEFFECT_LURKER;
		}
		break;
	case	STATUS_SLOWDOWN1:
		{
			m_i64Effect &= ~KEEPEFFECT_SLOWDOWN1;
		}
		break;
	case	STATUS_SLOWDOWN2:
		{
			m_i64Effect &= ~KEEPEFFECT_SLOWDOWN2;
		}
		break;
	case	STATUS_MAXLIFE:
		{
			m_i64Effect &= ~KEEPEFFECT_MAXLIFE;
		}
		break;
	case	STATUS_HIDDEN:
		{
			m_i64Effect &= ~KEEPEFFECT_HIDDEN;
		}
		break;
	case	STATUS_ADD_EXP:
		{
			m_i64Effect	&= ~KEEPEFFECT_ADD_EXP;
		}
		break;
	// 以下是结界系统相关的状态 ================
	case	STATUS_TEAMHEALTH:
		{
			m_i64Effect	&= ~KEEPEFFECT_TEAM_HEALTH;
		}
		break;
	case	STATUS_TEAMATTACK:
		{
			m_i64Effect	&= ~KEEPEFFECT_TEAM_ATTACK;
		}
		break;
	case	STATUS_TEAMDEFENCE:
		{
			m_i64Effect	&= ~KEEPEFFECT_TEAM_DEFENCE;
		}
		break;
	case	STATUS_TEAMSPEED:
		{
			m_i64Effect	&= ~KEEPEFFECT_TEAM_SPEED;
		}
		break;
	case	STATUS_TEAMEXP:
		{
			m_i64Effect	&= ~KEEPEFFECT_TEAM_EXP;
		}
		break;
	case	STATUS_TEAMSPIRIT:
		{
			m_i64Effect	&= ~KEEPEFFECT_TEAM_SPIRIT;
		}
		break;
	case	STATUS_TEAMCLEAN:
		{
			m_i64Effect	&= ~KEEPEFFECT_TEAM_CLEAN;
		}
		break;
	// 以上是结界系统相关状态 ===============
	case	STATUS_HEAL:
		{
			m_i64Effect &= ~KEEPEFFECT_HEAL;
		}
		break;
	case	STATUS_FAINT:
		{
			m_i64Effect &= ~KEEPEFFECT_FAINT;
		}
		break;
	case	STATUS_TRUCULENCE:
		{
			m_i64Effect &= ~KEEPEFFECT_TRUCULENCE;
		}
		break;
	case	STATUS_DAMAGE:
		{
			m_i64Effect &= ~KEEPEFFECT_DAMAGE;
		}
		break;
	case	STATUS_ATKER_DAMAGE:
		{
			m_i64Effect &= ~KEEPEFFECT_ATKER_DAMAGE;
		}
		break;
	case	STATUS_CONFUSION:
		{
			m_i64Effect &= ~KEEPEFFECT_CONFUSION;
		}
		break;
	default:
		ASSERT(!"switch status");
	}

	if(bSynchro && i64OldEffect != GetEffect())
	{
		CMsgUserAttrib msg;
		if (msg.Create(GetID(), _USERATTRIB_KEEPEFFECT, GetEffect()))
		{
			if (STATUS_MAXLIFE == nStatus)
			{
				msg.Append(_USERATTRIB_MAXLIFE, this->GetMaxLife());
				msg.Append(_USERATTRIB_LIFE, this->GetLife());
			}
			BroadcastRoomMsg(&msg, INCLUDE_SELF);
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
CItem* CNpc::Recycle(OBJID idUser)
{
	CHECKF(IsRecycleEnable());

	OBJID idType = GetInt(NPCDATA_ITEMTYPE);
	if(idType != 0)
	{
		CItem* pItem = CItem::CreateNew();
		IF_OK(pItem)
		{
			pItem->Create(GameDataDefault()->GetGameItemData(), idType, idUser, ITEMPOSITION_BACKPACK, GameDataDefault()->GetEudemonData());
			if(IsDynaNpc() && GetMaxLife() > 0 && GetLife() < GetMaxLife())
				pItem->SetInt(ITEMDATA_DATA, GetLife());
			return pItem;
		}
		else
			pItem->ReleaseByOwner();
	}

	return NULL;
}

/////////////////////////////////////////////////////////////////////////////
bool CNpc::IsOwnerOf(CUser* pUser, bool bMateEnable/*=false*/)
{
	CHECKF(pUser);

	if(IsSynNpc() && GetInt(NPCDATA_OWNERID) == pUser->GetSynID() && pUser->GetSynRankShow() == RANK_LEADER)
		return true;

	if(IsUserNpc() && GetInt(NPCDATA_OWNERID) == pUser->GetID())
		return true;

	if(bMateEnable && IsUserNpc() && GetInt(NPCDATA_OWNERID) == pUser->GetMateID())
		return true;

	return false;
}

/////////////////////////////////////////////////////////////////////////////
bool CNpc::IsSynMoneyEmpty()
{
	CHECKF(IsSynFlag());

	CSyndicate* pSyn = SynManager()->QuerySyndicate(GetInt(NPCDATA_OWNERID));
	if(pSyn)
	{
		if(pSyn->GetInt(SYNDATA_MONEY) > 0)
			return false;
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////
bool CNpc::CheckSortMutex()
{
	DWORD	dwSort = GetSort() & NPCSORT_USELINKID;

	if(GetType() == _SYNTRANS_NPC && dwSort != 0)
		return false;

	for(int i = 0; i < 32; i++)
	{
		if(dwSort == 0)
			return true;

		if((dwSort & 1) != 0 && (dwSort >>= 1) != 0)
		{
			ASSERT(!"_TBL_NPC(_TBL_DYNANPC) link id mutex!!!");
			return false;
		}
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////
void CNpc::CheckFightTime()
{
	time_t	tCurr	= time(NULL);
	tm*	pTm			= localtime(&tCurr);
	CHECK(pTm);
	int nCurrTime = tCurr;
/*	int nWeek		= pTm->tm_wday;
	int	nHour		= pTm->tm_hour;
	int nMinute		= pTm->tm_min;
	if(nWeek == 0)
		nWeek = 7;

	int	nCurrTime	= nWeek*1000000 + nHour*10000 + nMinute*100;
	int nStartTime	= (GetData(SYNFLAGNPC_FIGHTBEGIN)/100)*100;
	int nEndTime	= (GetData(SYNFLAGNPC_FIGHTEND)/100)*100;
	*/
	int nStartTime	= GetData(SYNFLAGNPC_FIGHTBEGIN);
	int nEndTime	= GetData(SYNFLAGNPC_FIGHTEND);

	if(nCurrTime >= nStartTime && nCurrTime < nEndTime)
	{
		if(!GetMap()->IsWarTime())
		{
			GetMap()->SetStatus(CGameMap::STATUS_WAR, true);

			CMsgTalk	msg;
			IF_OK_(msg.Create(STR_SYN_WAR_START))
				UserManager()->BroadcastMapMsg(GetMap()->GetID(), &msg);
 		}
	}
	else // if(!( 	nCurrTime >= nStartTime && nCurrTime < nEndTime ))
	{
		if(GetMap()->IsWarTime())
		{
			//攻城战结束后的处理
			OnFightEnd();
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
void CNpc::RecruitLife()
{
	if(IsAlive() && GetLife() < GetMaxLife() && GetData(SYNFLAGNPC_FIXFUND) > 0)
	{
		int nFixMoney = ::CutOverflow(GetData(SYNFLAGNPC_FIXFUND), MAX_FIXMONEY);
		int nLoseLife = GetMaxLife() - GetLife();
		nFixMoney = ::CutOverflow(nFixMoney, (nLoseLife-1) / FIXLIFE_PER_MONEY + 1);
		SetData(SYNFLAGNPC_FIXFUND, ::CutTrail(GetData(SYNFLAGNPC_FIXFUND) - nFixMoney, 0), UPDATE_FALSE);

		if(GetSynID() == ID_NONE)
			return ;
		CSyndicate* pSyn = SynManager()->QuerySyndicate(GetSynID());
		if(!pSyn)
		{
			return ;
		}
		if(pSyn->GetInt(SYNDATA_MONEY) < nFixMoney)
			nFixMoney = pSyn->GetInt(SYNDATA_MONEY);
		if(nFixMoney <= 0)
		{
			SetData(SYNFLAGNPC_FIXFUND, 0, UPDATE_FALSE);
			return ;
		}

		int nFixLife = ::CutOverflow(nLoseLife, nFixMoney * FIXLIFE_PER_MONEY);
		pSyn->QueryModify()->AddData(SYNDATA_MONEY, -1*nFixMoney);
		AddAttrib(_USERATTRIB_LIFE, nFixLife, SYNCHRO_BROADCAST);

		// effect
		CMsgMagicEffect	msg;
		IF_OK(msg.Create(GetID(), MAGICSORT_RECRUIT, 0, GetID(), nFixLife, GetDir()))
			BroadcastRoomMsg(&msg);
	}
}

/////////////////////////////////////////////////////////////////////////////
#include <map>
using namespace std;
void CNpc::BroadcastScore()
{
	typedef	multimap<int, OBJID>	TOP_SET;
	TOP_SET	setTop;

	OBJID idNpc = GetID();
	for(int i = 0; i < SynManager()->QuerySynSet()->GetAmount(); i++)
	{
		CSyndicate* pSyn = SynManager()->QuerySynSet()->GetObjByIndex(i);
		if(pSyn)
			setTop.insert(TOP_SET::value_type(pSyn->GetSynWarScore(idNpc), pSyn->GetID()));
	}

	int	nChannel = _TXTATR_SYNWAR_FIRST;
	i=1;
	for(TOP_SET::reverse_iterator iter = setTop.rbegin(); iter != setTop.rend() && i <= 5; iter++, i++)
	{
		OBJID	idSyn	= iter->second;
		int		nScore	= iter->first;
		if(nScore == 0)
			break;
		CSyndicate* pSyn = SynManager()->QuerySyndicate(idSyn);
		if(!pSyn)
			continue;

		MSGBUF	szMsg;
		sprintf(szMsg, STR_TOP_LIST_dsd, i, pSyn->GetStr(SYNDATA_NAME), nScore);
		CMsgTalk	msg;
		IF_OK(msg.Create(nChannel, szMsg))
			UserManager()->BroadcastMapMsg(GetMap()->GetID(), &msg);

		nChannel = _TXTATR_SYNWAR_NEXT;
	}
}

/////////////////////////////////////////////////////////////////////////////
LPCTSTR	CNpc::GetName()
{
	if(IsSynFlag() && GetInt(NPCDATA_OWNERID) != ID_NONE)
	{
		CSyndicate* pSyn = SynManager()->QuerySyndicate(GetInt(NPCDATA_OWNERID));
		if(pSyn)
			return pSyn->GetStr(SYNDATA_NAME);
	}

	return m_pData->GetStr(NPCDATA_NAME);
}

/////////////////////////////////////////////////////////////////////////////
bool CNpc::IsBeAtkable()
{
	if(IsSynFlag() && !GetMap()->IsWarTime())
		return false;

	return IsDynaNpc() && GetMaxLife() > 0;
}

/////////////////////////////////////////////////////////////////////////////
bool CNpc::SetSynOwnerID(OBJID idSyn, BOOL bWithLinkMap)		// true: with link map
{
	if(GetInt(NPCDATA_OWNERTYPE) != OWNER_SYN)
		return false;

	SetInt(NPCDATA_OWNERID, idSyn, true);

	if(bWithLinkMap && IsLinkNpc())
	{
		CGameMap* pMap = QueryLinkMap()->GetLinkMap();
		IF_OK(pMap)
			pMap->SetSynID(idSyn, true);		// true: with all npc in map
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////
bool CNpc::SetUserOwnerID(OBJID idUser, BOOL bWithLinkMap/*=false*/)		// true: with link map
{
	if(GetInt(NPCDATA_OWNERTYPE) != OWNER_USER)
		return false;

	SetInt(NPCDATA_OWNERID, idUser, true);

	if(bWithLinkMap && IsLinkNpc())
	{
		CGameMap* pMap = QueryLinkMap()->GetLinkMap();
		IF_OK(pMap)
			pMap->SetUserID(idUser, true);		// true: with all npc in map
	}

	return true;
}

/////////////////////////////////////////////////////////////////////////////
bool CNpc::IsDelEnable()
{
	if( (GetSort() & NPCSORT_DELENABLE) == 0 )
		return false;

	if(IsTrunkNpc() && !QueryTrunk()->IsEmpty())
		return false;

	return true;
}

/////////////////////////////////////////////////////////////////////////////
void CNpc::UpdateHoldFloor(bool bEnter)
{
	CHECK(GetMap());

	int nDirFront	= GetDir();
	int nDirBack	= (GetDir() + 4) % 8;
	int nDirLeft	= (GetDir() + 8 - 2) % 8;
	int nDirRight	= (GetDir() +2) % 8;

	POINT posFront, posBack, posLeft, posRight;
	posFront.x = GetPosX() + _DELTA_X[nDirFront] * this->GetInt(NPCDATA_SIZE_FRONT);
	posFront.y = GetPosY() + _DELTA_Y[nDirFront] * this->GetInt(NPCDATA_SIZE_FRONT);

	posBack.x = GetPosX() + _DELTA_X[nDirBack] * this->GetInt(NPCDATA_SIZE_BACK);
	posBack.y = GetPosY() + _DELTA_Y[nDirBack] * this->GetInt(NPCDATA_SIZE_BACK);
	
	posLeft.x = GetPosX() + _DELTA_X[nDirLeft] * this->GetInt(NPCDATA_SIZE_LEFT);
	posLeft.y = GetPosY() + _DELTA_Y[nDirLeft] * this->GetInt(NPCDATA_SIZE_LEFT);
	
	posRight.x = GetPosX() + _DELTA_X[nDirRight] * this->GetInt(NPCDATA_SIZE_RIGHT);
	posRight.y = GetPosY() + _DELTA_Y[nDirRight] * this->GetInt(NPCDATA_SIZE_RIGHT);

	int nMinX = __min(__min(posFront.x, posBack.x), __min(posLeft.x, posRight.x));
	int nMinY = __min(__min(posFront.y, posBack.y), __min(posLeft.y, posRight.y));
	
	int nMaxX = __max(__max(posFront.x, posBack.x), __max(posLeft.x, posRight.x));
	int nMaxY = __max(__max(posFront.y, posBack.y), __max(posLeft.y, posRight.y));

	for (int i=nMinX; i<=nMaxX; i++)
	{
		for (int j=nMinY; j<=nMaxY; j++)
		{
			if (GetMap()->IsValidPoint(i, j)
				&& !(GetPosX() == i && GetPosY() == j))
			{
				if (bEnter)
					GetMap()->IncRole(i, j);
				else
					GetMap()->DecRole(i, j);
			}
		}
	}
}



/////////////////////////////////////////////////////////////////////////////
//---jinggy---
OBJID CNpc::GetApplyAttackerSynID()
{
	return this->GetInt(NPCDATA_DATA1);
}
//---jinggy---
//对战争结束后的处理
void CNpc::OnFightEnd()
{
	GetMap()->SetStatus(CGameMap::STATUS_WAR, false);
	
	CMsgTalk	msg;
	IF_OK_(msg.Create(STR_SYN_WAR_END))		
		UserManager()->BroadcastMapMsg(GetMap()->GetID(), &msg);
	// stop all auto battal
	CRoleSet::Iterator pRole = RoleManager()->QuerySet()->NewEnum();
	while(pRole.Next())	
	{
		if(pRole  && pRole->GetMap()->GetID() == this->GetMapID())
			pRole->ClrAttackTarget();
	}
	
	//---jinggy---进行　战争后的条约处理---begin
	
	OBJID idSynApply = GetMap()->GetNpcSynWarLetter()->GetApplyAttackerSynID();//申请攻击的帮派ＩＤ

	
	if( idSynApply == this->GetSynID() || idSynApply<0)
		return;

	OBJID idOldSyn = GetSynID();

	int nScale=0, nWarValue=0;
	//得到 所有帮派NPC的血的丢失和 比例
	this->GetMap()->GetAllNpcLostLifeScaleAndValue(nScale,nWarValue);

	CNpc * pWarLetterNpc = GetMap()->GetNpcSynWarLetter();
	int nMoney=0;
	IF_OK(pWarLetterNpc)
	{
		nMoney = pWarLetterNpc->GetData(SYNWARLETTER_DEPOSIT);//押金
	}
	
	if(nScale>=50) //攻击方胜利，但没有占领SYNDATA_MONEY
	{
		CSyndicate * pSyn = SynManager()->QuerySyndicate(idSynApply);		
		nMoney = ::AddToTop(MulDiv(nWarValue,3,10), nMoney, SYNMONEY_LIMIT);		
		pSyn->QueryModify()->AddData(SYNDATA_MONEY, nMoney,true);
	}
	else//守护方胜利：攻击方赔偿70%，系统补偿50%。
	{
		int nMoneyApplySyn = nMoney;
		CSyndicate * pSyn = SynManager()->QuerySyndicate(GetSynID());
		
		nMoney = ::AddToTop(MulDiv(nMoney,70,100), MulDiv(nWarValue,50,100), SYNMONEY_LIMIT);		

		pSyn->QueryModify()->AddData(SYNDATA_MONEY, __max(0,nMoney),true);

		pSyn = SynManager()->QuerySyndicate(idSynApply);		
		pSyn->QueryModify()->AddData(SYNDATA_MONEY, ::CutRange(MulDiv(nMoneyApplySyn,30,100),0,SYNMONEY_LIMIT),true);
	}

	//---jinggy---进行　战争后的条约处理---end
}
//---jinggy---
//得到修理 最大生命值 所需要的钱
int CNpc::GetMaxFixMoney()
{
	return  ::CutRange(MulDiv(GetMaxLife()-1,1,FIXLIFE_PER_MONEY)+1,0,SYNMONEY_LIMIT);			
}
//---jinggy---
//将丢失的生命值计算成钱
int CNpc::GetLostFixMoney()
{
	int nLostLifeTmp = GetMaxLife() - GetLife() ;	
	return  ::CutRange(MulDiv(nLostLifeTmp-1,1,FIXLIFE_PER_MONEY)+1,0,SYNMONEY_LIMIT);	
}
//---jinggy---
//将占领的帮派地图的时间存放到 战书NPC中
void CNpc::SetOccupyTime()
{
	if(!this->IsSynWarLetter())
		return;

	time_t	tCur;		
	tCur = time(NULL);
	SetData(SYNWARLETTER_OCCUPYTIME,(int)tCur,true);
}