syndicate.cpp

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

	pInfo->nSize		= sizeof(SynFuncInfo0) + sizeof(int)*2;

	ASSERT(idx != SYNDATA_MONEY);
	ASSERT(idx != SYNDATA_REPUTE);
	MapGroup(This()->m_idProcess)->QuerySynMessage()->ChangeSyndicate(pInfo);
	return true;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::XSynModify::PresentMoney(OBJID idSyn, int nMoney, bool bSave)
{
	MESSAGESTR	buf;
	SynFuncInfo0*	pInfo = (SynFuncInfo0*)&buf;
	pInfo->idSyn		= This()->GetID();
	pInfo->ucFuncType	= SYNFUNC_PRESENT;
	pInfo->IntParam[0]	= idSyn;
	pInfo->IntParam[1]	= nMoney;
	pInfo->ucSaveFlag	= (unsigned char)bSave;
	pInfo->nSize		= sizeof(SynFuncInfo0) + sizeof(int)*2;

	MapGroup(This()->m_idProcess)->QuerySynMessage()->ChangeSyndicate(pInfo);
	return true;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::XSynModify::SetSynName(LPCTSTR szSynName, bool bSave)
{
	MESSAGESTR	buf;
	SynFuncInfo0*	pInfo = (SynFuncInfo0*)&buf;
	pInfo->idSyn		= This()->GetID();
	pInfo->ucFuncType	= SYNFUNC_SETSYNNAME;
	SafeCopy(pInfo->StrParam, szSynName, _MAX_NAMESIZE);
	pInfo->ucSaveFlag		= (unsigned char)bSave;
	pInfo->nSize		= sizeof(SynFuncInfo0) + _MAX_NAMESIZE;
	
	MapGroup(This()->m_idProcess)->QuerySynMessage()->ChangeSyndicate(pInfo);
	return true;
}

//////////////////////////////////////////////////////////////////////
// application
//////////////////////////////////////////////////////////////////////
int	CSyndicate::GetInt(SYNDATA idx)
{
	OBJID idFealty = m_pData->GetInt(SYNDATA_FEALTY);		// no loop
	if(idFealty != ID_NONE)
	{
		if(idx == SYNDATA_MONEY		// 基金合并
				|| idx >= SYNDATA_ENEMY0 && idx < SYNDATA_ENEMY0 + MAX_SYNENEMYSIZE
				|| idx >= SYNDATA_ALLY0 && idx < SYNDATA_ALLY0 + MAX_SYNALLYSIZE)
		{
			CSyndicate* pSyn = GetMasterSyn();
			IF_OK (pSyn)
				return pSyn->GetInt(idx);		// no loop
		}
	}

	return m_pData->GetInt(idx);		// no loop
}

//////////////////////////////////////////////////////////////////////
// 在本地线程广播子帮派消息
void CSyndicate::BroadcastLocalSynMsg(CNetMsg* pMsg, CUser* pExcludeSender)
{
	CHECK(pMsg);
	CUserManager::Iterator pUser = UserManager()->NewEnum();
	while(pUser.Next())
	{
		if(pUser && pUser->GetSynID() == GetID() 
				&& !(pExcludeSender && pExcludeSender->GetID() == pUser->GetID()) )
		{
			pUser->SendMsg(pMsg);
		}
	}
}

//////////////////////////////////////////////////////////////////////
// 在本线程中广播总帮派消息(含子帮派)
void CSyndicate::BroadcastSynMsg(CNetMsg* pMsg, CUser* pExcludeSender)
{
	CSyndicate* pMaster = this->GetMasterSyn();
	CHECK(pMaster);
	pMaster->BroadcastLocalSynMsg(pMsg, pExcludeSender);

	{
		OBJID idMaster = pMaster->GetID();
		CHECK(idMaster != ID_NONE);
		for(int i = 0; i < SynManager()->QuerySynSet()->GetAmount(); i++)
		{
			CSynPtr pSyn = SynManager()->QuerySynSet()->GetObjByIndex(i);
			if(pSyn && pSyn->GetInt(SYNDATA_FEALTY) == idMaster)
			{
				//分队-----begin
				for(int j = 0; j < SynManager()->QuerySynSet()->GetAmount(); j++)  
				{
					CSyndicate* pSynTeam = SynManager()->QuerySynSet()->GetObjByIndex(j);
					if(pSynTeam && pSynTeam->GetInt(SYNDATA_FEALTY) == pSyn->GetID())
					{
						pSynTeam->BroadcastLocalSynMsg(pMsg, pExcludeSender);
					}						
				}
				//分队-----end
				
				pSyn->BroadcastLocalSynMsg(pMsg, pExcludeSender);
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////
// 在世界中广播总帮派消息(含子帮派)
void CSyndicate::BroadcastSubSynMsg(SOCKET_ID idSocket, OBJID idNpc, LPCTSTR szMsg, CUser* pExcludeSender, LPCTSTR pszEmotion, DWORD dwColor, int nAttribute)
{
	CHECK(szMsg);
	CMsgTalk	msg;
	IF_OK(msg.Create(SYSTEM_NAME, ALLUSERS_NAME, szMsg, pszEmotion, dwColor, nAttribute))
		BroadcastSynMsg(&msg, pExcludeSender);

	MapGroup(PID)->QueryIntraMsg()->TransmitMsg(&msg, idSocket, idNpc);
}

//////////////////////////////////////////////////////////////////////
LPCTSTR CSyndicate::GetFealtyName()
{
	OBJID idFealty = GetInt(SYNDATA_FEALTY);
	if(idFealty)
	{
		CSyndicate* pSyn = SynManager()->QuerySyndicate(idFealty);
		if(pSyn)
			return pSyn->GetStr(SYNDATA_NAME);
	}

	return SYNNAME_NONE;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::IsNearSyn(OBJID idTarget)
{
	if(idTarget == ID_NONE)
		return false;

	if(GetID() == idTarget)
		return true;

	CSyndicate* pTarget = SynManager()->QuerySyndicate(idTarget);
	if(!pTarget)		// 帮派柱子的帮派ID可能无效
		return false;

	if(pTarget->GetInt(SYNDATA_FEALTY) == ID_NONE)
	{
		if(GetInt(SYNDATA_FEALTY) == idTarget)
			return true;
	}
	else
	{
		if(pTarget->GetInt(SYNDATA_FEALTY) == GetID() || pTarget->GetInt(SYNDATA_FEALTY) == GetInt(SYNDATA_FEALTY))
			return true;
	}

	return false;
}

//////////////////////////////////////////////////////////////////////
CSyndicate* CSyndicate::GetMasterSyn()
{
	if(GetInt(SYNDATA_FEALTY) != ID_NONE)
	{
		CSyndicate* pFealtySyn= SynManager()->QuerySyndicate(GetInt(SYNDATA_FEALTY));

		IF_OK(pFealtySyn)
		{
			return pFealtySyn->GetMasterSyn();
		}
	}

	return this;
}

//////////////////////////////////////////////////////////////////////
void CSyndicate::SendInfoToClient(CUser* pUser)
{
	CHECK(pUser);

	for(int i = 0; i < MAX_SYNENEMYSIZE; i++)
	{
		if(this->GetInt((SYNDATA)(SYNDATA_ENEMY0+i)) != ID_NONE)
		{
			CMsgSyndicate	msg;
			IF_OK(msg.Create(SET_ANTAGONIZE, this->GetInt((SYNDATA)(SYNDATA_ENEMY0+i))))
				pUser->SendMsg(&msg);
		}
	}

	for( i = 0; i < MAX_SYNALLYSIZE; i++)
	{
		if(this->GetInt((SYNDATA)(SYNDATA_ALLY0+i)) != ID_NONE)
		{
			CMsgSyndicate	msg;
			IF_OK(msg.Create(SET_ALLY, this->GetInt((SYNDATA)(SYNDATA_ALLY0+i))))
				pUser->SendMsg(&msg);
		}
	}

/*	OBJID idMaster = GetID();
	if(GetInt(SYNDATA_FEALTY) != 0)
		idMaster = GetInt(SYNDATA_FEALTY);
	CHECK(idMaster != ID_NONE);
	{
		CMsgSyndicate	msg;
		IF_OK(msg.Create(SET_MAINSYN, idMaster))
			pUser->SendMsg(&msg);
	}
	for( i = 0;  i < SynManager()->QuerySynSet()->GetAmount(); i++)
	{
		CSynPtr pSyn = SynManager()->QuerySynSet()->GetObjByIndex(i);
		if(pSyn && pSyn->GetInt(SYNDATA_FEALTY) == idMaster)
		{
			CMsgSyndicate	msg;
			IF_OK(msg.Create(SET_SUBSYN, pSyn->GetID()))
				pUser->SendMsg(&msg);
		}
	}*/

	OBJID idSyn = this->GetID();
	CMsgSyndicate	msg;
	IF_OK(msg.Create(SET_SYN, idSyn, this->GetInt(SYNDATA_FEALTY)))
		pUser->SendMsg(&msg);

	IF_OK(msg.Create(SYN_SET_PUBLISHTIME, idSyn, this->GetInt(SYNDATA_PUBLISHTIME)))
		pUser->SendMsg(&msg);

	// 子帮派
	for( i = 0; i < SynManager()->QuerySynSet()->GetAmount(); i++)  
	{
		CSyndicate* pSyn = SynManager()->QuerySynSet()->GetObjByIndex(i);
		if(pSyn && pSyn->GetInt(SYNDATA_FEALTY) == idSyn)
		{
			pSyn->SendInfoToClient(pUser);
		}
	}

	if (this->IsMasterSyn())
	{
		LPCTSTR pTenet = GetStr(SYNDATA_TENET);
		if(strlen(pTenet) > 0)
			pUser->SendSysMsg(_TXTATR_SYNTENET, pTenet);
		LPCTSTR pAnnounce = GetStr(SYNDATA_ANNOUNCE);
		if(strlen(pAnnounce) > 0)
			pUser->SendSysMsg(_TXTATR_SYNANNOUNCE, pAnnounce);
	}
}

//////////////////////////////////////////////////////////////////////
// syn war -------------------------------------
//////////////////////////////////////////////////////////////////////
void CSyndicate::AddSynWarScore(OBJID idNpc, int nScore)
{
	for(int i = 0; i < m_setSynWarScore.size(); i++)
	{
		if(m_setSynWarScore[i].idNpc == idNpc)
		{
			m_setSynWarScore[i].nScore	+= nScore;
			return;
		}
	}

	SynWarInfo	info;
	info.idNpc		= idNpc;
	info.nScore		= nScore;
	m_setSynWarScore.push_back(info);
}

//////////////////////////////////////////////////////////////////////
int CSyndicate::GetSynWarScore(OBJID idNpc)
{
	for(int i = 0; i < m_setSynWarScore.size(); i++)
	{
		if(m_setSynWarScore[i].idNpc == idNpc)
			return m_setSynWarScore[i].nScore;
	}
	return 0;
}

//////////////////////////////////////////////////////////////////////
void CSyndicate::ClearSynWarScore(OBJID idNpc)
{
	for(int i = 0; i < m_setSynWarScore.size(); i++)
	{
		if(m_setSynWarScore[i].idNpc == idNpc)
		{
			m_setSynWarScore.erase(m_setSynWarScore.begin() + i);
			return ;
		}
	}
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::IsFriendly(OBJID idTarget, BOOL bNest)
{
	if(idTarget == ID_NONE)
		return false;
	CSyndicate* pTarget = SynManager()->QuerySyndicate(idTarget);
	CHECKF(pTarget);
	idTarget = pTarget->GetMasterSynID();

	if(bNest && GetInt(SYNDATA_FEALTY) != ID_NONE)
	{
		CSyndicate* pSyn = SynManager()->QuerySyndicate(GetInt(SYNDATA_FEALTY));
		IF_OK(pSyn)
			return pSyn->IsFriendly(idTarget);
	}

	for(int i = SYNDATA_ALLY0; i < SYNDATA_ALLY0 + MAX_SYNALLYSIZE; i++)
	{
		if(GetInt((SYNDATA)i) == idTarget)
			return true;
	}

	return false;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::IsHostile(OBJID idTarget, BOOL bNest)
{
	CSyndicate* pTarget = SynManager()->QuerySyndicate(idTarget);
	idTarget = pTarget->GetMasterSynID();

	if(bNest && GetInt(SYNDATA_FEALTY) != ID_NONE)
	{
		CSyndicate* pSyn = SynManager()->QuerySyndicate(GetInt(SYNDATA_FEALTY));
		IF_OK(pSyn)
			return pSyn->IsHostile(idTarget);
	}

	for(int i = SYNDATA_ENEMY0; i < SYNDATA_ENEMY0 + MAX_SYNENEMYSIZE; i++)
	{
		if(GetInt((SYNDATA)i) == idTarget)
			return true;
	}

	return false;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::IsNeutral(OBJID idSyn)
{
	if(!IsFriendly(idSyn) && !IsHostile(idSyn))
		return true;

	return false;
}

//////////////////////////////////////////////////////////////////////
int CSyndicate::GetMemberAmount(bool bIncludeSub)
{
	int nMemberSum	= GetInt(SYNDATA_AMOUNT);
	
	if (bIncludeSub)
	{
		// 子帮派人数
		for(int i = 0; i < SynManager()->QuerySynSet()->GetAmount(); i++)  
		{
			CSyndicate* pSyn = SynManager()->QuerySynSet()->GetObjByIndex(i);
			if(pSyn && pSyn->GetInt(SYNDATA_FEALTY) == this->GetID())
			{	
				nMemberSum += pSyn->GetMemberAmount(bIncludeSub);
			}
		}
	}
	
	return nMemberSum;
}

//////////////////////////////////////////////////////////////////////
int CSyndicate::GetSynAmount()
{
	if(!IsMasterSyn())
	{
		CSyndicate * pMainSyn = this->GetMasterSyn();
		CHECKF(pMainSyn);
		return pMainSyn->GetMemberAmount(true);
	}	

	return GetMemberAmount(true);
}

//////////////////////////////////////////////////////////////////////
void CSyndicate::SetNewSubName(LPCTSTR szName)		// 临时代码
{
	m_pData->SetStr(SYNDATA_NAME, szName, _MAX_NAMESIZE);
	m_pData->Update();
}

//////////////////////////////////////////////////////////////////////@
bool CSyndicate::IsWhiteSynMapOwner()
{
	return GetID() == SynManager()->GetMapSynID(SET_WHITE_SYN);
}

//////////////////////////////////////////////////////////////////////@
bool CSyndicate::IsBlackSynMapOwner()
{
	return GetID() == SynManager()->GetMapSynID(SET_BLACK_SYN);
}

//////////////////////////////////////////////////////////////////////@
bool CSyndicate::ClearAllySyn(CSyndicate* pTargetSyn)
{
	// 检查帮派
	CHECKF (pTargetSyn);
	
	for(int i = 0; i < MAX_SYNALLYSIZE; i++)
	{
		OBJID idTarget = GetInt((SYNDATA)(SYNDATA_ALLY0+i));
		if(idTarget == pTargetSyn->GetID())
		{
			QueryModify()->SetData((SYNDATA)(SYNDATA_ALLY0+i), ID_NONE, true);		// true: 必须save
			break;
		}
	}
	for( i = 0; i < MAX_SYNALLYSIZE; i++)
	{
		OBJID idTarget = pTargetSyn->GetInt((SYNDATA)(SYNDATA_ALLY0+i));
		if(idTarget == GetID())
		{
			pTargetSyn->QueryModify()->SetData((SYNDATA)(SYNDATA_ALLY0+i), ID_NONE, true);		// true: 必须save
			break;
		}
	}
	CMsgSyndicate	msg;
	IF_OK(msg.Create(CLEAR_ALLY, pTargetSyn->GetID()))
		MapGroup(PID)->QueryIntraMsg()->SendNpcMsg(GetID(), &msg);

	return true;
}

//////////////////////////////////////////////////////////////////////@
bool CSyndicate::ClearEnemySyn(CSyndicate* pTargetSyn)
{
	// 检查帮派
	CHECKF (pTargetSyn);