syndicate.cpp

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

// Syndicate.cpp: implementation of the CSyndicate class.
//
//////////////////////////////////////////////////////////////////////

#include "AllMsg.h"
#include "Syndicate.h"
#include "MapGroup.h"

//////////////////////////////////////////////////////////////////////
char	szSynTable[] = _TBL_SYNDICATE;

MYHEAP_IMPLEMENTATION(CSyndicate,s_heap)
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CSyndicate::CSyndicate()
{
	SetObjType(OBJ_SYN);
	m_pData	= NULL;
	m_obj.m_pOwner	= this;
	m_link.Init(this);
}

//////////////////////////////////////////////////////////////////////
CSyndicate::~CSyndicate()
{
	if(m_pData)
	{
		m_pData->Update();
		m_pData->Release();
	}
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::Create(IRecordset* pRes)
{
	ASSERT(!m_pData);

	m_pData = CSynBase::CreateNew();
	CHECKF(m_pData);
	IF_NOT(m_pData->Create(pRes))
		return false;

	if(m_pData->GetInt(SYNDATA_DEL_FLAG) != 0)		// 已删除的帮派
		return false;

	return true;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::ReloadData()
{
	ASSERT(m_pData);

/*		//??? 单服务器，不需要RELOAD
	CSynBase* pData = CSynBase::CreateNew();
	CHECKF(pData);
	IF_NOT(pData->Create(GetID(), Database()))
	{
		pData->Release();
		return false;
	}

	if(pData->GetInt(SYNDATA_DEL_FLAG) != 0)		// 已删除的帮派
	{
		pData->Release();
		return false;
	}

	m_pData->Release();
	m_pData	= pData;
*/
	return true;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::Create(const CreateSyndicateInfo* pInfo, bool bSave)
{
	ASSERT(!m_pData);

	OBJID idSyn = bSave ? ID_NONE : pInfo->idSyn;
	m_pData = CSynBase::CreateNew();
	CHECKF(m_pData);
	IF_NOT(m_pData->Create(GameDataDefault()->GetSynData(), idSyn))
		return false;

	m_pData->SetInt(SYNDATA_ID, idSyn);
	m_pData->SetStr(SYNDATA_NAME, pInfo->szName, _MAX_NAMESIZE);
	m_pData->SetStr(SYNDATA_TENET, pInfo->szTenet, MAX_TENETSIZE);
	m_pData->SetStr(SYNDATA_ANNOUNCE, pInfo->szLeaderTitle, MAX_TENETSIZE);
	m_pData->SetStr(SYNDATA_MEMBERTITLE, pInfo->szMemberTitle, _MAX_NAMESIZE);
	m_pData->SetInt(SYNDATA_LEADERID, pInfo->idLeader);
	m_pData->SetStr(SYNDATA_LEADERNAME, pInfo->szLeader, _MAX_NAMESIZE);
	m_pData->SetInt(SYNDATA_MONEY, pInfo->nMoney);
	m_pData->SetInt(SYNDATA_FEALTY, pInfo->idFealty);
	m_pData->SetInt(SYNDATA_MANTLE_FALG, pInfo->nMantle);
	m_pData->SetInt(SYNDATA_RANK, 1);
	
	if(pInfo->nSynFlag ==0)
		m_pData->SetInt(SYNDATA_AMOUNT, 1);
	else
		m_pData->SetInt(SYNDATA_AMOUNT, 0);

	m_pData->SetInt(SYNDATA_REPUTE, 0);
	if(bSave)
	{
		return m_pData->InsertRecord() != ID_NONE;
	}
	else
	{
		m_pData->ClearUpdateFlags();
		return true;
	}
}

//////////////////////////////////////////////////////////////////////
// modify
//////////////////////////////////////////////////////////////////////
bool CSyndicate::Demise(OBJID idOldLeader,int nOldSynMemberLevel,OBJID idNewLeader, LPCTSTR szNewLeader, int nNewSynMemberLevel, OBJID idBackSyn, bool bSave)	
{
	if(!( idOldLeader==(OBJID)m_pData->GetInt(SYNDATA_LEADERID) || (OBJID)m_pData->GetInt(SYNDATA_LEADERID)==ID_NONE ))	//? 兼容于旧数据
		return false;

	NAMESTR	szNewLeader2;	
	SafeCopy(szNewLeader2, szNewLeader, _MAX_NAMESIZE);

	m_pData->SetInt(SYNDATA_LEADERID, idNewLeader);
	m_pData->SetStr(SYNDATA_LEADERNAME, szNewLeader2, _MAX_NAMESIZE);
	if(bSave)
		m_pData->Update();
	else
		m_pData->ClearUpdateFlags();

	CUser* pOldUser = UserManager()->GetUser(idOldLeader);
	if(pOldUser)
	{
		pOldUser->QuerySynAttr()->SetIdRank(GetID(), RANK_NEWBIE);
		pOldUser->QuerySynAttr()->SaveInfo();
		pOldUser->QuerySynAttr()->SynchroInfo();
	}

	CUser* pNewUser = UserManager()->GetUser(idNewLeader);
	if(pNewUser)
	{
		pNewUser->QuerySynAttr()->SetIdRank(this->GetID(), RANK_LEADER);
		pNewUser->QuerySynAttr()->SaveInfo();
		pNewUser->QuerySynAttr()->SynchroInfo();
	}

	CMsgSynInfo	msg;
	if(msg.Create(this))
		this->BroadcastSynMsg(&msg);
	
	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::SetTenet(LPCTSTR szTenet, bool bSave)
{
	CHECKF(strlen(szTenet)<MAX_TENETSIZE);
	
	m_pData->SetStr(SYNDATA_TENET, szTenet, MAX_TENETSIZE);
	if(bSave)
		m_pData->Update();
	else
		m_pData->ClearUpdateFlags();
	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::SetLeaderTitle(LPCTSTR szLeaderTitle, bool bSave)
{
	m_pData->SetStr(SYNDATA_ANNOUNCE, szLeaderTitle, MAX_TENETSIZE);
	if(bSave)
		m_pData->Update();
	else
		m_pData->ClearUpdateFlags();
	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::SetMemberTitle(LPCTSTR szMemberTitle, bool bSave)
{
	m_pData->SetStr(SYNDATA_MEMBERTITLE, szMemberTitle, _MAX_NAMESIZE);
	if(bSave)
		m_pData->Update();
	else
		m_pData->ClearUpdateFlags();
	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::AddData(SYNDATA idx, int nData, bool bSave)
{
	int nOldMoney	= m_pData->GetInt(SYNDATA_MONEY);

	int nAllData = ::AddToTop(m_pData->GetInt(idx), nData, SYNMONEY_LIMIT);		// use for money or amount
	m_pData->SetInt(idx, nAllData);
	if(bSave)
		m_pData->Update();
	else
		m_pData->ClearUpdateFlags();

	if(nOldMoney > 0 && m_pData->GetInt(SYNDATA_MONEY) <= 0)
	{
		CMsgTalk	msg;
		IF_OK(msg.Create(_TXTATR_GM, STR_DESTROY_SYNDICATE_SOON))
			BroadcastSynMsg(&msg);
	}

	{
		this->SynchroInfo();
	}

	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::SetData(SYNDATA idx, int nData, bool bSave)
{
	int	nOldData = m_pData->GetInt(idx);
	m_pData->SetInt(idx, nData);
	if(bSave)
		m_pData->Update();
	else
		m_pData->ClearUpdateFlags();

	// synchro
	SynchroInfo();
	if(idx >= SYNDATA_ENEMY0 && idx < SYNDATA_ENEMY0+MAX_SYNENEMYSIZE)
	{
		CMsgSyndicate msg;
		if(nData)
		{
			IF_OK(msg.Create(SET_ANTAGONIZE, nData))
				BroadcastSynMsg(&msg);
		}
		else
		{
			IF_OK(msg.Create(CLEAR_ANTAGONIZE, nOldData))
				BroadcastSynMsg(&msg);
		}
	}
	else if(idx >= SYNDATA_ALLY0 && idx < SYNDATA_ALLY0+MAX_SYNALLYSIZE)
	{
		CMsgSyndicate msg;
		if(nData)
		{
			IF_OK(msg.Create(SET_ALLY, nData))
				BroadcastSynMsg(&msg);
		}
		else
		{
			IF_OK(msg.Create(CLEAR_ALLY, nOldData))
				BroadcastSynMsg(&msg);
		}
	}

	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::PresentMoney(OBJID idSyn, int nMoney, bool bSave)
{
	if(nMoney <= 0 || m_pData->GetInt(SYNDATA_MONEY) < nMoney)
		return false;
	CSyndicate* pTarget = SynManager()->QuerySyndicate(idSyn);
	if(!pTarget)
		return false;

	m_pData->SetInt(SYNDATA_MONEY, m_pData->GetInt(SYNDATA_MONEY)-nMoney);
	pTarget->m_pData->SetInt(SYNDATA_MONEY, pTarget->m_pData->GetInt(SYNDATA_MONEY)+nMoney);
	if(bSave)
	{
		m_pData->Update();
		pTarget->m_pData->Update();
	}
	else
	{
		m_pData->ClearUpdateFlags();
		pTarget->m_pData->ClearUpdateFlags();
	}
	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::SetSynName(LPCTSTR szSynName, bool bSave)
{
	m_pData->SetStr(SYNDATA_NAME, szSynName, _MAX_NAMESIZE);
	if(bSave)
		m_pData->Update();
	else
		m_pData->ClearUpdateFlags();
	return true; 
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::ChangeSyndicate(const SynFuncInfo0* pFuncInfo)
{
	CHECKF(pFuncInfo->idSyn == GetID());

	switch(pFuncInfo->ucFuncType)
	{
	case	SYNFUNC_DEMISE:
		return Demise(pFuncInfo->IntParam[0], pFuncInfo->IntParam[3],pFuncInfo->IntParam[1], (LPCTSTR)&pFuncInfo->IntParam[5], pFuncInfo->IntParam[2],pFuncInfo->IntParam[4], pFuncInfo->ucSaveFlag!=0);
		break;
	case	SYNFUNC_SETTENET:
		{
			bool bRet = (SetTenet(pFuncInfo->StrParam, pFuncInfo->ucSaveFlag!=0)
							&& SetData(SYNDATA_PUBLISHTIME, pFuncInfo->dwData[0], pFuncInfo->ucSaveFlag!=0));
			if (bRet)
			{
				CMsgSyndicate msg;
				if (msg.Create(SYN_SET_PUBLISHTIME, GetID(), GetInt(SYNDATA_PUBLISHTIME)))
					BroadcastSynMsg(&msg);
			}
			return bRet;
		}
		break;
	case	SYNFUNC_SETLEADERTITLE:
		return SetLeaderTitle(pFuncInfo->StrParam, pFuncInfo->ucSaveFlag!=0);
		break;
	case	SYNFUNC_SETMEMBERTITLE:
		return SetMemberTitle(pFuncInfo->StrParam, pFuncInfo->ucSaveFlag!=0);
		break;
	case	SYNFUNC_ADDDATA:
		return AddData((SYNDATA)pFuncInfo->IntParam[0], pFuncInfo->IntParam[1], pFuncInfo->ucSaveFlag!=0);
		break;
	case	SYNFUNC_SETDATA:
		return SetData((SYNDATA)pFuncInfo->IntParam[0], pFuncInfo->IntParam[1], pFuncInfo->ucSaveFlag!=0);
		break;
	case	SYNFUNC_PRESENT:
		return PresentMoney(pFuncInfo->IntParam[0], pFuncInfo->IntParam[1], pFuncInfo->ucSaveFlag!=0);
		break;
	case	SYNFUNC_SETSYNNAME:
		return SetSynName(pFuncInfo->StrParam, pFuncInfo->ucSaveFlag!=0);
		break;
	default:
		ASSERT(!"switch CSyndicate::ChangeSyndicate()");
		break;
	}
	return false;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::XSynModify::Demise(OBJID idOldLeader,int nOldSynMemberLevel,OBJID idNewLeader, LPCTSTR szNewLeader, int nNewSynMemberLevel, OBJID idBackSyn, bool bSave)	
{
	MESSAGESTR	buf;
	SynFuncInfo0*	pInfo = (SynFuncInfo0*)&buf;
	pInfo->idSyn		= This()->GetID();
	pInfo->ucFuncType	= SYNFUNC_DEMISE;
	pInfo->IntParam[0]	= idOldLeader;
	pInfo->IntParam[1]	= idNewLeader;
	pInfo->IntParam[2]	= idBackSyn;
	pInfo->IntParam[3]	= nOldSynMemberLevel;
	pInfo->IntParam[4]	= nNewSynMemberLevel;
	SafeCopy((char*)(&(pInfo->IntParam[5])), szNewLeader, _MAX_NAMESIZE);
	pInfo->ucSaveFlag		= (unsigned char)bSave;
	pInfo->nSize		= sizeof(SynFuncInfo0) + sizeof(int)*3 + _MAX_NAMESIZE;

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

//////////////////////////////////////////////////////////////////////
bool CSyndicate::XSynModify::SetTenet(LPCTSTR szTenet, bool bSave)
{
	MESSAGESTR	buf;
	SynFuncInfo0*	pInfo = (SynFuncInfo0*)&buf;
	pInfo->idSyn		= This()->GetID();
	pInfo->dwData[0]	= DateStamp();
	pInfo->ucFuncType	= SYNFUNC_SETTENET;
	SafeCopy(pInfo->StrParam, szTenet, MAX_TENETSIZE);
	pInfo->ucSaveFlag		= (unsigned char)bSave;
	pInfo->nSize		= sizeof(SynFuncInfo0) + MAX_TENETSIZE;

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

//////////////////////////////////////////////////////////////////////
bool CSyndicate::XSynModify::SetLeaderTitle(LPCTSTR szLeaderTitle, bool bSave)
{
	MESSAGESTR	buf;
	SynFuncInfo0*	pInfo = (SynFuncInfo0*)&buf;
	pInfo->idSyn		= This()->GetID();
	pInfo->ucFuncType	= SYNFUNC_SETLEADERTITLE;
	SafeCopy(pInfo->StrParam, szLeaderTitle, _MAX_NAMESIZE);
	pInfo->ucSaveFlag		= (unsigned char)bSave;
	pInfo->nSize		= sizeof(SynFuncInfo0) + _MAX_NAMESIZE;

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

//////////////////////////////////////////////////////////////////////
bool CSyndicate::XSynModify::SetMemberTitle(LPCTSTR szMemberTitle, bool bSave)
{
	MESSAGESTR	buf;
	SynFuncInfo0*	pInfo = (SynFuncInfo0*)&buf;
	pInfo->idSyn		= This()->GetID();
	pInfo->ucFuncType	= SYNFUNC_SETMEMBERTITLE;
	SafeCopy(pInfo->StrParam, szMemberTitle, _MAX_NAMESIZE);
	pInfo->ucSaveFlag		= (unsigned char)bSave;
	pInfo->nSize		= sizeof(SynFuncInfo0) + _MAX_NAMESIZE;

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

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

	if ((idx == SYNDATA_MONEY || idx == SYNDATA_REPUTE) && This()->GetInt(SYNDATA_FEALTY) != ID_NONE)
	{
		CSyndicate* pSyn = This()->GetMasterSyn();
		IF_OK (pSyn)
			pInfo->idSyn = pSyn->GetID();					// 基金合并，声望也合并
	}
	MapGroup(This()->m_idProcess)->QuerySynMessage()->ChangeSyndicate(pInfo);
	return true;
}

//////////////////////////////////////////////////////////////////////
bool CSyndicate::XSynModify::SetData(SYNDATA idx, int nData, bool bSave)
{
	MESSAGESTR	buf;
	SynFuncInfo0*	pInfo = (SynFuncInfo0*)&buf;
	pInfo->idSyn		= This()->GetID();
	pInfo->ucFuncType	= SYNFUNC_SETDATA;
	pInfo->IntParam[0]	= idx;
	pInfo->IntParam[1]	= nData;
	pInfo->ucSaveFlag	= (unsigned char)bSave;