abilitymanager.cpp

墨香最新私服

// AbilityManager.cpp: implementation of the CAbilityManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "AbilityManager.h"
#include "MHFile.h"
#include "AbilityGroup.h"
#include "AbilityUpdater.h"
#include "Player.h"
#ifdef _MHCLIENT_
#include "ChatManager.h"
#else
#include "MapDBMsgParser.h"
#endif

GLOBALTON(CAbilityManager);

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAbilityManager::CAbilityManager()
{
	m_InfoTable.Initialize(8);
	m_pPool = new CMemoryPoolTempl<CAbility>;
#ifdef _MHCLIENT_
	m_pPool->Init(50,10,"ABILITY");
#else
	m_pPool->Init(1000,100,"ABILITY");
#endif
}

CAbilityManager::~CAbilityManager()
{
	delete m_pPool;
	Release();
}

void CAbilityManager::Init()
{
	CMHFile file;
#ifdef _FILE_BIN_
	if(!file.Init("./Resource/AbilityBaseInfo.bin", "rb"))
		return;
#else
	if(!file.Init("./Resource/AbilityBaseInfo.txt", "rt"))
		return;
#endif

	while(1)
	{
		if(file.IsEOF())
			break;

		CAbilityInfo* pInfo = new CAbilityInfo(&file);
		m_InfoTable.Add(pInfo,pInfo->GetIdx());
	}

	file.Release();
}
void CAbilityManager::Release()
{
	CAbilityInfo* pInfo;
	m_InfoTable.SetPositionHead();
	while(pInfo = m_InfoTable.GetData())
	{
		delete pInfo;
	}
	m_InfoTable.RemoveAll();

	//Singleton栏肺 父惦 皋葛府 秦力 鞘夸绝澜
	//PTRLISTSEARCHSTART(m_UpdaterList,CAbilityUpdater*,pUpdater)
	//	delete pUpdater;
	//PTRLISTSEARCHEND

	m_UpdaterList.RemoveAll();
}

void CAbilityManager::AddUpdater(CAbilityUpdater* pUpdater)
{
	m_UpdaterList.AddTail(pUpdater);
}

void CAbilityManager::InitAbility(CPlayer* pObject,ABILITY_TOTALINFO* pTotalInfo,CAbilityGroup* pAbilityGroup)
{
	pAbilityGroup->Init(pTotalInfo);
	
	// update
	UpdateAbilityState(ABILITYUPDATE_ABILITYINITED,0,pAbilityGroup);
}

void CAbilityManager::InitAbilityExp(CAbilityGroup* pAbilityGroup,DWORD AbilityExp)
{
	pAbilityGroup->SetAbilityExp(AbilityExp);
}

CAbilityInfo* CAbilityManager::GetAbilityInfo(WORD AbilityIndex)
{
	CAbilityInfo* pInfo = m_InfoTable.GetData(AbilityIndex);
//	ASSERT(pInfo);
	return pInfo;	
}

int CAbilityManager::GetState(CAbilityGroup* pGroup,CAbilityInfo* pAbilityInfo)
{
	if(pGroup->GetAbility(pAbilityInfo->GetIdx()) != NULL)
		return eAIS_Usable;
	
	// 焊捞绰瘤 八荤
	if( pAbilityInfo->GetInfo()->Ability_AcquireKind == eAAK_CharacterLevel )
	{
		ASSERT(pGroup->GetOwenerObject()->GetObjectKind() & eObjectKind_Player);
		LEVELTYPE level = ((CPlayer*)pGroup->GetOwenerObject())->GetLevel();
		LEVELTYPE needlevel = pAbilityInfo->GetInfo()->Ability_AcquireParam1;
		if( level >= needlevel )
			return eAIS_OnlyVisible;
	}

	return eAIS_NotAvailable;
}

void CAbilityManager::UpdateAbilityState(DWORD Flag,DWORD Param,CAbilityGroup* pAbilityGroup)
{
	PTRLISTSEARCHSTART(m_UpdaterList,CAbilityUpdater*,pUpdater)
		pUpdater->Update(Flag,Param,pAbilityGroup,&m_InfoTable);
	PTRLISTSEARCHEND

}

void CAbilityManager::GetAbilityTotalInfo(CAbilityGroup* pGroup,ABILITY_TOTALINFO* pOutAbilityTotalInfo)
{
	CAbility* pAbility;
	for(int n=0;n<eAGK_Max;++n)
	{
		memset(pOutAbilityTotalInfo->AbilityDataArray[n],ABILITYLEVEL_DB_KEY,MAX_ABILITY_NUM_PER_GROUP);
		pOutAbilityTotalInfo->AbilityDataArray[n][MAX_ABILITY_NUM_PER_GROUP] = 0;

		memset(pOutAbilityTotalInfo->AbilityQuickPositionArray[n],ABILITYQUICKPOSITION_NULL,MAX_ABILITY_NUM_PER_GROUP);
		pOutAbilityTotalInfo->AbilityQuickPositionArray[n][MAX_ABILITY_NUM_PER_GROUP] = 0;
	}
	//"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
	
	// to each Ability

	// make Array like.. "DDAAAABAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAA"
	BYTE Kind,Position;
	pGroup->SetPositionHead();
	while(pAbility = pGroup->GetNextAbility(eAGK_Max))
	{
		GetKindPosition_WithAbilityIndex(pAbility->GetIndex(),&Kind,&Position);
		pOutAbilityTotalInfo->AbilityDataArray[Kind][Position] += pAbility->GetLevel();

		if(pAbility->GetQuickPosition())
		{
			pOutAbilityTotalInfo->AbilityQuickPositionArray[Kind][Position] = 
				ABILITYQUICKPOSITION_KEY + pAbility->GetQuickPosition() - TP_QUICK_START;
		}
	}
}

BOOL CAbilityManager::UpgradeAbility(WORD AbilityIndex, CAbilityGroup* pAbilityGroup)
{
	CAbilityInfo* pAbilInfo = GetAbilityInfo(AbilityIndex);
	if(pAbilInfo == NULL)
		return FALSE;
	if(!CanUpgrade(pAbilInfo, pAbilityGroup))
		return FALSE;
	
	//劳洒妨绰 绢呼 饭骇
	BYTE AbilityLevel = 0;
	CAbility* pAbility = pAbilityGroup->GetAbility(AbilityIndex);
	if(pAbility)
		AbilityLevel = pAbility->GetLevel();

	DWORD NeedAbilityExp = pAbilInfo->GetAbilityGradeExp(AbilityLevel+1);
	DWORD FromAbilityExp = pAbilityGroup->GetAbilityExp();
	DWORD ToAbilityExp = FromAbilityExp - NeedAbilityExp;

	if(FromAbilityExp < NeedAbilityExp || ToAbilityExp > 1000000)
	{
#ifdef _MAPSERVER_
		AbilityLevelupLog(pAbilityGroup->GetOwenerObject(),
			AbilityIndex,(pAbility ? pAbility->GetLevel() : 0) +100,
			FromAbilityExp,ToAbilityExp);

		return FALSE;
#endif
	}
	
	pAbilityGroup->SetAbilityExp(ToAbilityExp);

	BYTE AbilLevel = 0;
	if(pAbility == NULL)
	{
		pAbilityGroup->AddAbility(pAbilInfo,1,0);
		AbilLevel = 1;
	}
	else
	{		
		pAbility->IncreaseLevel();
		AbilLevel = pAbility->GetLevel();
	}

	// update
	UpdateAbilityState(ABILITYUPDATE_ABILITYLEVEL_CHANGED,0,pAbilityGroup);
	
#ifdef _MAPSERVER_
	CharacterHeroInfoUpdate(pAbilityGroup->GetOwenerObject());
	AbilityLevelupLog(pAbilityGroup->GetOwenerObject(),
					AbilityIndex,AbilLevel,
					FromAbilityExp,ToAbilityExp);
#endif
	
	return TRUE;
}

BOOL CAbilityManager::SetAbilityQuickPosition(WORD AbilityIndex, POSTYPE QuickPosition,CAbilityGroup* pAbilityGroup)
{
	CAbility* pAbility = pAbilityGroup->GetAbility(AbilityIndex);
	if(pAbility == NULL)
		return FALSE;

	pAbility->SetQuickPosition(QuickPosition);

	// update
	UpdateAbilityState(ABILITYUPDATE_ABILITYQUICK_CHANGED,0,pAbilityGroup);
	
	return TRUE;
}

BOOL CAbilityManager::CanUpgrade(CAbilityInfo* pAbilInfo, CAbilityGroup* pAbilityGroup)
{
	//劳洒妨绰 绢呼 饭骇
	BYTE AbilityLevel = 0;
	CAbility* pAbility = pAbilityGroup->GetAbility(pAbilInfo->GetIdx());
	if(pAbility)
		AbilityLevel = pAbility->GetLevel();

	DWORD NeedAbilityExp = pAbilInfo->GetAbilityGradeExp(AbilityLevel+1);
	DWORD CurAbilityExp = pAbilityGroup->GetAbilityExp();
	if(NeedAbilityExp > CurAbilityExp)
	{
#ifdef _MHCLIENT_
		CHATMGR->AddMsg( CTC_SYSMSG, CHATMGR->GetChatMsg(624) );
#endif
		return FALSE;
	}
	
	return TRUE;
}

BOOL CAbilityManager::CheckAbilityLevel(WORD AbilityIndex,CAbilityGroup* pAbilityGroup,BYTE Level)
{
	BYTE AbilityLevel = 0;
	CAbility* pAbility = pAbilityGroup->GetAbility(AbilityIndex);
	if(pAbility)
		AbilityLevel = pAbility->GetLevel();

	return AbilityLevel >= Level;
}
BYTE CAbilityManager::GetAbilityLevel(WORD AbilityIndex,CAbilityGroup* pAbilityGroup)
{
	BYTE AbilityLevel = 0;
	CAbility* pAbility = pAbilityGroup->GetAbility(AbilityIndex);
	if(pAbility)
		AbilityLevel = pAbility->GetLevel();

	return AbilityLevel;
}
CAbility* CAbilityManager::MakeNewAbility()
{
	return m_pPool->Alloc();
}
void CAbilityManager::ReleaseAbility(CAbility* pAbility)
{
	m_pPool->Free(pAbility);
}







void CAbilityManager::__TranData()
{
	CMHFile file;
	file.Init("src.txt","r");
	FILE* fpout = fopen("out.txt","w");
	ABILITY_TOTALINFO abiltotalinfo;

	char name[20];
	while(1)
	{
		if(file.IsEOF() != FALSE)
			break;

		DWORD PlayerID = file.GetDword();
		file.GetString(name);
		file.GetString(abiltotalinfo.AbilityDataArray[0]);
		file.GetString(abiltotalinfo.AbilityDataArray[1]);
		file.GetString(abiltotalinfo.AbilityDataArray[2]);
		file.GetString(abiltotalinfo.AbilityDataArray[3]);

		CAbilityGroup group;
		group.Init(&abiltotalinfo);
		group.SetPositionHead();
		while(CAbility* pAbility = group.GetNextAbility(eAGK_Max))
		{
			CAbilityInfo* pInfo = pAbility->GetAbilityInfo();
			fprintf(fpout,"%d\t%s\t%d\t%s\n",PlayerID,name,pInfo->GetIdx(),pInfo->GetInfo()->Ability_name);
		}

		group.Release();
	}

	fclose(fpout);
	file.Release();
}