skillmanager.cpp

奇迹世界 部分源代码奇迹世界 部分源代码奇迹世界 部分源代码

#include "stdafx.h"
#include "SkillManager.h"
#include "Skill.h"
#include "SkillFactory.h"
#include "SkillInfoParser.h"
#include "Ability.h"
#include "SkillAttrCalculator.h"
#include "Player.h"
#include "SCSkillSlot.h"
#include "ItemManager.h"
#include "SCSkillSlotContainer.h"
#include "SlotManager.h"
#include "ItemInfoParser.h"
#include "SCQuickSlotContainer.h"
#include "SCQuickSlot.h"
#include "SCQuickStyleSlot.h"
#include "SCQuickStyleSlotContainer.h"
#include "QuickStyleManager.h"
#include "SummonManager.h"
#include "Summoned.h"
#include "SummonedNPCs.h"


SkillManager::SkillManager()
{
	m_pPassiveSkillHashTable = new util::SolarHashTable<Skill*>;
	m_pPassiveSkillHashTable->Initialize( DEFAULT_POOL_SIZE );
}

SkillManager::~SkillManager()
{	
	Release();

	SAFE_DELETE( m_pPassiveSkillHashTable );
}
VOID SkillManager::Init( SlotManager  * pMGR )
{
	m_pPlayer				= pMGR->m_pPlayer;
	m_pSkillSlotContainer	= (SCSkillSlotContainer*)pMGR->GetSlotContainer(SI_SKILL);
	m_pQuickSlotContainer	= (SCQuickSlotContainer*)pMGR->GetSlotContainer(SI_QUICK);
	m_pStyleSlotContainer	= (SCQuickStyleSlotContainer*)pMGR->GetSlotContainer(SI_STYLE);
	m_pSlotMGR				= pMGR;
	m_PreStyleCode			= 0;

}
VOID SkillManager::Release()
{
	// 菩矫宏 胶懦 秦力
	Skill *pSkill = NULL;
	m_pPassiveSkillHashTable->SetFirst();
	while( ( pSkill = m_pPassiveSkillHashTable->GetNext() ) != NULL )
	{
		SkillFactory::Instance()->FreeSkill( pSkill );
		m_pPassiveSkillHashTable->Remove( pSkill->GetSkillCode() );
	}
}

BOOL SkillManager::ValidState()
{
	return m_pSlotMGR->ValidState();
}

BOOL SkillManager::IsEmpty( POSTYPE pos )
{
	return m_pSlotMGR->IsEmpty(SI_SKILL, pos);
}
VOID SkillManager::SerializeSkillStream( POSTYPE pos, SKILLSTREAM * IN pStream, eSERIALIZE eType )
{
	GetSkillSlotContainer()->SerializeSkillStream( pos, pStream, eType );
	if( eType == SERIALIZE_STORE )
	{
		AddAttrForPassiveSkill( pStream->SkillPart.wCode );
	}
}

VOID SkillManager::AddAttrForPassiveSkill( SLOTCODE SkillCode )
{
	SkillScriptInfo *pBaseSkillInfo = (SkillScriptInfo *)SkillInfoParser::Instance()->GetSkillInfo( SkillCode );
	if( !pBaseSkillInfo )	return;

	// 菩矫宏 胶懦父 殿废茄促.
	if( pBaseSkillInfo->m_bySkillType != SKILL_TYPE_PASSIVE )	return;

	// 货肺款 胶懦俊 措秦 皋葛府甫 且寸罐绊 胶懦沥焊甫 悸泼茄促.
	Skill* pNewSkill = (Skill*)SkillFactory::Instance()->AllocSkill( SKILL_TYPE_PASSIVE, pBaseSkillInfo );
	if( !pNewSkill )		
	{
		SUNLOG( eCRITICAL_LOG,  "[SkillManager::AddAttrForPassiveSkill] Can't Alloc PassiveSkill!" );
		return;
	}

	SkillInfo SkillInfoData;
	SkillInfoData.m_SkillCode = SkillCode;
	pNewSkill->Init( m_pPlayer, &SkillInfoData, pBaseSkillInfo );

	// 菩矫宏 胶懦府胶飘俊 殿废茄促.
	AddPassiveSkill( pNewSkill );
}

// dwDelayTick捞 0老 版快 StartExecute角青 饶 胶懦 贸府 场
VOID SkillManager::AddPassiveSkill( Skill *pSkill )
{
	// 菩矫宏 胶懦 眠啊
	if( pSkill->GetSkillType() == SKILL_TYPE_PASSIVE )
	{
		ApplyPassiveSkill( pSkill );

		m_pPassiveSkillHashTable->Add( pSkill, pSkill->GetSkillCode() );
	}
}

BOOL SkillManager::DelPassiveSkill( SLOTCODE SkillCode )
{
	Skill *pSkill = m_pPassiveSkillHashTable->GetData( SkillCode );
	if( !pSkill )	return FALSE;

	// 菩矫宏 胶懦 昏力
	if( pSkill->GetSkillType() == SKILL_TYPE_PASSIVE )
	{
		// 扁瓷阑 秦力茄 饶 力芭茄促.
		ReleasePassiveSkill( pSkill );

		// 力芭
		m_pPassiveSkillHashTable->Remove( pSkill->GetSkillCode() );
		SkillFactory::Instance()->FreeSkill( pSkill );
		return TRUE;
	}

	return FALSE;
}

BOOL SkillManager::ApplyPassiveSkill( Skill *pSkill )
{
	SkillScriptInfo *pBaseSkillInfo = (SkillScriptInfo *)SkillInfoParser::Instance()->GetSkillInfo( pSkill->GetSkillCode() );
	if( !pBaseSkillInfo )	return FALSE;

	// 捞固 利侩登绢 乐绰 胶懦牢瘤 眉农
	if( pSkill->IsApplied() )	return FALSE;

	// 胶懦 荤侩 炼扒 眉农
	if( !m_pPlayer->CanApplyPassiveSkill( pSkill->GetSkillCode() ) )	return FALSE;

	BASE_ABILITYINFO * pAbilityInfo = NULL ;
	pBaseSkillInfo->SetFirst();
	while( pAbilityInfo = pBaseSkillInfo->GetNext() )
	{
		eATTR_TYPE eAttrID = pAbilityInfo->GetAttrType();

		// 傀锹 付胶磐府狼 版快 2啊瘤 颇扼固磐甫 棵府骨肺 抗寇贸府!
		if( pAbilityInfo->m_wAbilityID == eABILITY_WEAPON_MASTERY )
		{
			SkillAttrCalculator SkillCalc( m_pPlayer->GetAttr() );

			// 傍拜仿 刘皑(弥家, 弥措)
			SkillCalc.AddAttr( eATTR_OPTION_ALL_ATTACK_POWER, VALUE_TYPE_VALUE, pAbilityInfo->m_iParam[0] );

			// 傍拜 加档 刘皑
			SkillCalc.AddAttr( eATTR_ATTACK_SPEED, VALUE_TYPE_VALUE, pAbilityInfo->m_iParam[1] );
		}

		// 胶乔复 单固瘤狼 版快俊档 2啊瘤 颇扼固磐甫 棵府骨肺 抗寇贸府茄促.
		if( pAbilityInfo->m_wAbilityID == eABILITY_BONUS_DAMAGE_PER_SP )
		{
			SkillAttrCalculator SkillCalc( m_pPlayer->GetAttr() );

			// 拱府 傍拜仿阑 棵妨霖促.(荐摹)
			SkillCalc.AddAttr( eATTR_OPTION_PHYSICAL_ATTACK_POWER, VALUE_TYPE_VALUE, pAbilityInfo->m_iParam[0] );

			// 拱府 傍拜仿阑 棵妨霖促.(欺季飘)
			int iAddValue = SkillCalc.AddAttr( eATTR_OPTION_PHYSICAL_ATTACK_POWER, VALUE_TYPE_PERCENT_PER_CUR, pAbilityInfo->m_iParam[1] );
			pSkill->SetValueType( VALUE_TYPE_VALUE );
			pSkill->SetValue( iAddValue );
		}

		// 颇扼固磐甫 棵妨林绰 绢呼府萍牢啊
		if( eAttrID != eATTR_TYPE_INVALID )
		{
			SkillAttrCalculator SkillCalc( m_pPlayer->GetAttr() );
			int iAddValue = SkillCalc.AddAttr( eAttrID, pAbilityInfo->m_iParam[0], pAbilityInfo->m_iParam[1] );
			pSkill->SetValueType( VALUE_TYPE_VALUE );
			pSkill->SetValue( iAddValue );
		}
	}

	pSkill->SetApply( TRUE );

	return TRUE;
}

VOID SkillManager::ReleasePassiveSkill( Skill *pSkill )
{
	SkillScriptInfo *pBaseSkillInfo = (SkillScriptInfo *)SkillInfoParser::Instance()->GetSkillInfo( pSkill->GetSkillCode() );
	if( !pBaseSkillInfo )	return;

	// 捞固 利侩登绢 乐绰 胶懦牢瘤 眉农
	if( !pSkill->IsApplied() )	return;

	BASE_ABILITYINFO * pAbilityInfo = NULL ;
	pBaseSkillInfo->SetFirst();
	while( pAbilityInfo = pBaseSkillInfo->GetNext() )
	{
		eATTR_TYPE eAttrID = pAbilityInfo->GetAttrType();

		// 傀锹 付胶磐府狼 版快 2啊瘤 颇扼固磐甫 棵府骨肺 抗寇贸府!
		if( pAbilityInfo->m_wAbilityID == eABILITY_WEAPON_MASTERY )
		{
			SkillAttrCalculator SkillCalc( m_pPlayer->GetAttr() );

			// 傍拜仿 刘皑(弥家, 弥措)
			SkillCalc.DelAttr( eATTR_OPTION_ALL_ATTACK_POWER, VALUE_TYPE_VALUE, pAbilityInfo->m_iParam[0] );

			// 傍拜 加档 刘皑
			SkillCalc.DelAttr( eATTR_ATTACK_SPEED, VALUE_TYPE_VALUE, pAbilityInfo->m_iParam[1] );
		}

		// 胶乔复 单固瘤狼 版快俊档 2啊瘤 颇扼固磐甫 棵府骨肺 抗寇贸府茄促.
		if( pAbilityInfo->m_wAbilityID == eABILITY_BONUS_DAMAGE_PER_SP )
		{
			SkillAttrCalculator SkillCalc( m_pPlayer->GetAttr() );

			// 拱府 傍拜仿阑 棵妨霖促.(荐摹)
			SkillCalc.DelAttr( eATTR_OPTION_PHYSICAL_ATTACK_POWER, VALUE_TYPE_VALUE, pAbilityInfo->m_iParam[0] );

			// 拱府 傍拜仿阑 棵妨霖促.(欺季飘)
			SkillCalc.DelAttr( eATTR_OPTION_PHYSICAL_ATTACK_POWER, pSkill->GetValueType(), pSkill->GetValue() );
		}

		// 颇扼固磐甫 棵妨林绰 绢呼府萍牢啊
		if( eAttrID != eATTR_TYPE_INVALID )
		{
			SkillAttrCalculator SkillCalc( m_pPlayer->GetAttr() );
			SkillCalc.DelAttr( eAttrID, pSkill->GetValueType(), pSkill->GetValue() );
		}
	}

	pSkill->SetApply( FALSE );
}

//-------------------------------------------------------------------------------------------------
// 胶懦 嚼垫
//-------------------------------------------------------------------------------------------------

RC::eSKILL_RESULT SkillManager::CanLevelUpSkill( SLOTCODE CurSkillCode, SLOTCODE NewSkillCode )
{
	if( !ValidState() ) return RC::RC_SKILL_FAILED;

	// dwCurSkillCode俊 秦寸窍绰 胶懦阑 嚼垫窍绊 乐绰瘤 眉农
	SCSkillSlotContainer *pContainer = GetSkillSlotContainer();
	SCSkillSlot *pCurSkillSlot = pContainer->GetSkillSlotByCode( CurSkillCode );
	if( !pCurSkillSlot )	return RC::RC_SKILL_DOES_NOT_HAVE;

	SkillScriptInfo *pBaseCurSkillInfo = SkillInfoParser::Instance()->GetSkillInfo( CurSkillCode );
	if( !pBaseCurSkillInfo )	return RC::RC_SKILL_BASEINFO_NOTEXIST;

	// 胶懦饭骇捞 父肪(LV10)牢 版快, 坷滚啊瓷 饭骇 眉农 鞘夸!!!
	if( pBaseCurSkillInfo->m_wSkillLv >= MAX_SKILL_LEVEL )		return RC::RC_SKILL_MAX_LEVEL_LIMIT;

	// 货肺款 胶懦狼 夸备炼扒阑 父练窍绰瘤 眉农
	return CanLearnSkill( NewSkillCode );
}

class QuickSkillLevelUp
{
	BOOL		m_bComplete;
	SLOTCODE	m_CurSkillCode;
	SLOTCODE	m_NewSkillCode;
public:
	QuickSkillLevelUp( SLOTCODE CurSkillCode, SLOTCODE NewSkillCode ) : m_CurSkillCode(CurSkillCode), 
		m_NewSkillCode(NewSkillCode), m_bComplete(0) {}

	VOID operator () ( SCSlot* pSlot )
	{
		SCQuickSlot *pQuickSlot = (SCQuickSlot*)pSlot;

		if( m_bComplete )									return;
		if( pQuickSlot->GetOrgCode() != m_CurSkillCode )	return;

		pQuickSlot->SetOrgCode( m_NewSkillCode );
		m_bComplete = TRUE;
	}
};

VOID SkillManager::LevelUpSkill( SLOTCODE CurSkillCode, SLOTCODE NewSkillCode, SKILLSLOT & OUT NewSkillSlot )
{
	if( !ValidState() ) return;

	// 泅犁 胶懦浇吩
	SCSkillSlot *pCurSkillSlot = m_pSkillSlotContainer->GetSkillSlotByCode( CurSkillCode );
	if( !pCurSkillSlot )	return;

	// 货酚霸 胶懦浇吩 沥焊甫 悸泼茄促.
	SCSkillSlot rNewSlot;
	rNewSlot.SetCode( NewSkillCode );
	rNewSlot.SetPos( pCurSkillSlot->GetPos() );

	// 泅犁 胶懦浇吩阑 昏力茄促.
	m_pSkillSlotContainer->DeleteSlot( pCurSkillSlot->GetPos(), NULL );

	// 货酚霸 胶懦浇吩阑 眠啊茄促.
	m_pSkillSlotContainer->InsertSlot( rNewSlot.GetPos(), rNewSlot );

    // NewSkillSlot俊 蔼阑 悸泼茄促.
	NewSkillSlot.m_SkillPos = rNewSlot.GetPos();
	rNewSlot.CopyOut( NewSkillSlot.m_Stream );

	// QuickSlot俊 胶懦捞 殿废登绢 乐促搁 饭骇诀 矫难霖促.
	QuickSkillLevelUp Opr( CurSkillCode, NewSkillCode );
	m_pQuickSlotContainer->ForEachSlot( Opr );

	// 菩矫宏 胶懦捞扼搁 捞傈胶懦阑 力芭窍绊 货肺款 胶懦阑 眠啊茄促.
	DelPassiveSkill( CurSkillCode );
	AddAttrForPassiveSkill( NewSkillCode );

	// 家券眉 胶懦捞扼搁 捞傈胶懦阑 力芭窍绊 货肺款 胶懦阑 眠啊茄促.
	SummonManager::Instance()->DelSummonedSkill( m_pPlayer->GetSummonerKey(), CurSkillCode );
	SummonManager::Instance()->AddSummonedSkill( m_pPlayer->GetSummonerKey(), NewSkillCode );
}

RC::eSKILL_RESULT SkillManager::CanLearnSkill( SLOTCODE NewSkillCode )
{
	if( !ValidState() ) return RC::RC_SKILL_FAILED;

	// dwNewSkillCode俊 秦寸窍绰 胶懦捞 胶懦胶农赋飘俊 粮犁窍绰瘤 眉农
	SkillScriptInfo *pBaseNewSkillInfo = SkillInfoParser::Instance()->GetSkillInfo( NewSkillCode );
	if( !pBaseNewSkillInfo )	return RC::RC_SKILL_BASEINFO_NOTEXIST;

	// 秦寸 努贰胶狼 胶懦阑 捞固 嚼垫窍绊 乐栏哥, 扁粮狼 饭骇捞 货肺款 饭骇焊促 鞍芭唱 臭阑 版快
	SCSkillSlotContainer *pContainer = GetSkillSlotContainer();
	SCSkillSlot *pCurSkillSlot = pContainer->GetSkillSlotByClass( pBaseNewSkillInfo->m_SkillClassCode );
	if( pCurSkillSlot )		
	{
		SkillScriptInfo *pBaseCurSkillInfo = SkillInfoParser::Instance()->GetSkillInfo( pCurSkillSlot->GetCode() );

		if( pBaseCurSkillInfo->m_wSkillLv >= pBaseNewSkillInfo->m_wSkillLv )	return RC::RC_SKILL_ALREADY_EXIST_SKILL;
	}

	// 巢篮 胶懦器牢飘啊 夸备胶懦器牢飘焊促 利篮 版快
	if( m_pPlayer->GetCharInfo()->m_dwRemainSkill < pBaseNewSkillInfo->m_byRequireSkillPoint )	
		return RC::RC_SKILL_REMAIN_SKILLPOINT_LACK;

	// 货肺款 胶懦狼 夸备饭骇阑 父练窍绰瘤 眉农
	if( m_pPlayer->GetLevel() < pBaseNewSkillInfo->m_wRequireLv )					return RC::RC_SKILL_REQUIRE_LEVEL_LIMIT;

	// 货肺款 胶懦狼 夸备槛访档甫 父练窍绰瘤 眉农
	if( m_pPlayer->GetExperty1() < pBaseNewSkillInfo->m_wRequireSkillStat[0] )	return RC::RC_SKILL_REQUIRE_SKILLSTAT_LIMIT;
	if( m_pPlayer->GetExperty2() < pBaseNewSkillInfo->m_wRequireSkillStat[1] )	return RC::RC_SKILL_REQUIRE_SKILLSTAT_LIMIT;

	// 某腐磐 努贰胶 炼扒捞 嘎绰瘤 眉农
	if( pBaseNewSkillInfo->m_bySkillUserType == eSKILL_USER_PLAYER )
	{
		if( !m_pPlayer->CheckClassDefine( pBaseNewSkillInfo->m_bySkillUserType, pBaseNewSkillInfo->m_dwClassDefine ) )
			return RC::RC_SKILL_CHAR_CLASS_LIMIT;
	}

	return RC::RC_SKILL_SUCCESS;
}

VOID SkillManager::LearnSkill( SLOTCODE NewSkillCode, SKILLSLOT & OUT NewSkillSlot )
{