itemmanager.cpp

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

#include "stdafx.h"
#include <ResultCode.h>
#include "SCSlotContainer.h"
#include ".\itemmanager.h"
#include "InventorySlotContainer.h"
#include "EquipmentSlotContainer.h"
#include "WarehouseSlotContainer.h"
#include "TempStoreSlotContainer.h"
#include "SkillSlotContainer.h"
#include "Player.h"
#include "Field.h"
#include "Sector.h"
#include "ItemInfoParser.h"
#include "Item.h"
#include "ObjectFactory.h"
#include "DropManager.h"
#include <ShopInfoParser.h>
#include "ItemAttrCalculator.h"

#include "SkillAttrCalculator.h"
#include "SkillInfoParser.h"
#include "Ability.h"
#include <PacketStruct_DG.h>
#include <PacketStruct_CG.h>
#include "SkillFactory.h"
#include "Skill.h"
#include "NumericValues.h"
#include "ItemFormula.h"
#include "SlotManager.h"
#include "Map.h"
#include "GameServer.h"

ItemManager::ItemManager()
{
//	m_SerialCodeCheck.Initialize(1000);
}

ItemManager::~ItemManager()
{
	Release();
}

VOID ItemManager::Release()
{
//	m_SerialCodeCheck.RemoveAll();
}

VOID ItemManager::Init( SlotManager * pMGR )
{
	m_pPlayer			= pMGR->m_pPlayer;
	m_ppSlotContainer	= pMGR->m_pSlotContainer;
	m_pSlotMGR			= pMGR;
	// 檬扁蔼
	m_FunctionalType	= eFUNCTIONALTYPE_ALL;
//	m_SerialCodeCheck.RemoveAll();
}

BOOL ItemManager::IsEmpty( SLOTIDX Index, POSTYPE pos )
{
	ASSERT( Index < SI_MAX );
	ASSERT( Index != SI_SKILL );
	return m_pSlotMGR->IsEmpty( Index, pos );
}

SCItemSlotContainer * ItemManager::GetItemSlotContainer( SLOTIDX Index )
{
	ASSERT( Index < SI_MAX );
	ASSERT( Index != SI_SKILL );
	return (SCItemSlotContainer *)m_pSlotMGR->GetSlotContainer(Index);
}

BOOL ItemManager::ValidPos( SLOTIDX atIndex, POSTYPE atPos, BOOL bEmptyCheck )
{
	if( atIndex == SI_SKILL ) return FALSE;
	return m_pSlotMGR->ValidPos(atIndex, atPos, bEmptyCheck);
}
BOOL ItemManager::ValidContainer( SLOTIDX atIndex )
{
	return m_pSlotMGR->ValidContainer(atIndex);
}
BOOL ItemManager::ValidState()
{
	return m_pSlotMGR->ValidState();
}

VOID ItemManager::SerializeItemStream( SLOTIDX Index, POSTYPE pos, ITEMSTREAMEX * IN pStream, eSERIALIZE eType )
{
	ASSERT( Index < SI_MAX );
	ASSERT( Index != SI_SKILL );
	GetItemSlotContainer(Index)->SerializeItemStream( pos, pStream, eType );
	if( eType == SERIALIZE_STORE )
	{
		if( pStream->ItemPart.dwSerial == TEMP_DBSERIAL_VALUE )
		{
			// 矫府倔 惯鞭
			GetItemSlotContainer(Index)->SetLock( pos, TRUE );
			MSG_DG_ITEM_SERIAL_SYN msg;
			msg.m_dwKey = m_pPlayer->GetUserKey();
			msg.m_SlotIdx = Index;
			msg.m_ItemPos = pos;
			m_pPlayer->SendToGameDBPServer( &msg, sizeof(msg) );
		}
		else if( IsDupSerialCode(pStream->ItemPart.dwSerial) )
		{
			// 吝汗 矫府倔 虐 惯积
			// 浇吩俊促啊 遏阑 八
			// 吝汗 矫府倔 版绊 菩哦 傈崔
			// GetItemSlotContainer(Index)->SetValidState(FALSE);
			DISPMSG( "吝汗 矫府倔 惯积!!!\n" );
		}
	}
}

VOID ItemManager::AddSerialCode( SLOTIDX Index, DBSERIAL serial )				
{ 
	/*
	if( serial == TEMP_DBSERIAL_VALUE )
	{
		// 公矫
		// 芒绊老版快 版绊
		if( Index == SI_WAREHOUSE || Index == SI_EQUIPMENT )
		{
			DISPMSG( "[Slot:%u]版绊!!!矫府倔 99999惯积\n", Index );
		}
	}
	else if( IsDupSerialCode(serial) )
	{
		// 吝汗 矫府倔 虐 惯积
		// 浇吩俊促啊 遏阑 八
		// 吝汗 矫府倔 版绊 菩哦 傈崔
		// GetItemSlotContainer(Index)->SetValidState(FALSE);
		DISPMSG( "[Slot:%u]吝汗矫府倔(%u) 惯积!!!\n", Index, serial );
	}
	else
		m_SerialCodeCheck.Add( serial, serial );
	*/
}

VOID ItemManager::SerializeItemStream( SLOTIDX Index, POSTYPE pos, ITEMSTREAM * IN pStream, eSERIALIZE eType )
{
	ASSERT( Index < SI_MAX );
	ASSERT( Index != SI_SKILL );
	GetItemSlotContainer(Index)->SerializeItemStream( pos, pStream, eType );
	if( eType == SERIALIZE_STORE )
	{
		if( pStream->ItemPart.dwSerial == TEMP_DBSERIAL_VALUE )
		{
			// 矫府倔 惯鞭
			GetItemSlotContainer(Index)->SetLock( pos, TRUE );
			MSG_DG_ITEM_SERIAL_SYN msg;
			msg.m_dwKey = m_pPlayer->GetUserKey();
			msg.m_SlotIdx = Index;
			msg.m_ItemPos = pos;
			m_pPlayer->SendToGameDBPServer( &msg, sizeof(msg) );
		}
		else if( IsDupSerialCode(pStream->ItemPart.dwSerial) )
		{
			// 吝汗 矫府倔 虐 惯积
			// 浇吩俊促啊 遏阑 八
			// 吝汗 矫府倔 版绊 菩哦 傈崔
			//GetItemSlotContainer(Index)->SetValidState(FALSE);
			DISPMSG( "吝汗 矫府倔 惯积!!!\n" );
		}
		else
		{
			//m_SerialCodeCheck.Add( pStream->ItemPart.dwSerial, pStream->ItemPart.dwSerial );
		}
	}
}

VOID ItemManager::UpdateAttrForEquipItem()
{
	ItemAttrCalculator itemCalc( m_pPlayer->GetAttr(), *(GetItemSlotContainer(SI_EQUIPMENT)) );
	itemCalc.UpdateAll();
}


// 荤侩矫 林狼痢 : SLITIDX狼 葛电 浇吩阑 iterate窍扁 锭巩俊 加档啊 蠢副 堪妨啊 乐澜
// OPT //@@ 唱吝俊 秦浆肺 贸府秦杭鳖?
BOOL ItemManager::IsExistItem( SLOTIDX Index, SLOTCODE code )
{
	SCSlotContainer * pContainer = GetItemSlotContainer(Index);
	for( POSTYPE pos = 0 ; pos < pContainer->GetMaxSlotNum() ; ++pos )
	{
		const SCSlot & rSlot = pContainer->GetSlot(pos);
		if( rSlot.GetCode() == code )
		{
			return TRUE;
		}
	}

	return FALSE;
}


RC::eITEM_RESULT ItemManager::Move( SLOTIDX fromIndex, POSTYPE fromPos, SLOTIDX toIndex, POSTYPE toPos )
{
	if( !ValidState() ) 
		return RC::RC_ITEM_INVALIDSTATE;
	// Validate 眉农 风凭 鞘荐!!!!!	
	if( !ValidPos( fromIndex, fromPos ) )
		return RC::RC_ITEM_INVALIDPOS;
	if( !ValidPos(  toIndex,  toPos, FALSE ) )
		return RC::RC_ITEM_INVALIDPOS;

	// Validate 眉农 风凭 鞘荐!!!!!
	SCSlotContainer * pFromContainer	= GetItemSlotContainer( fromIndex );
	SCSlotContainer * pToContainer		= GetItemSlotContainer( toIndex );

	SCItemSlot FromSlot;

	pFromContainer->DeleteSlot( fromPos, &FromSlot );
	if( TRUE == pToContainer->IsEmpty( toPos ) )
	{
		// 茄 规氢 捞悼
		if( !pToContainer->InsertSlot( toPos, FromSlot ) )
		{
			pFromContainer->InsertSlot( fromPos, FromSlot );
			return RC::RC_ITEM_UNKNOWNERROR;
		}
	}
	else
	{
		// 背券
		SCItemSlot ToSlot;
		pToContainer->DeleteSlot( toPos, &ToSlot );
		if( !pFromContainer->InsertSlot( fromPos, ToSlot ) )
		{
			//rollback
			pFromContainer->InsertSlot( fromPos, FromSlot );
			pToContainer->InsertSlot( toPos, ToSlot );
			return RC::RC_ITEM_UNKNOWNERROR;
		}
		if( !pToContainer->InsertSlot( toPos, FromSlot ) )
		{
			//rollback
			pFromContainer->DeleteSlot( fromPos, NULL );

			pFromContainer->InsertSlot( fromPos, FromSlot );
			pToContainer->InsertSlot( toPos, ToSlot );
			return RC::RC_ITEM_UNKNOWNERROR;
		}
	}

	return RC::RC_ITEM_SUCCESS;
}

RC::eITEM_RESULT ItemManager::DropMoney( MONEY Money )
{
	if( !ValidState() ) 
		return RC::RC_ITEM_INVALIDSTATE;

	// Field俊 冻绢 哆府扁

	if( Money > m_pPlayer->GetMoney() )
	{
		return RC::RC_ITEM_HAVENOTMONEY;
	}

	WzVector wvCurPos = m_pPlayer->GetRandomPosInAround(2);
	if( !g_DropManager.DropMoneyToField( m_pPlayer->GetField(), &wvCurPos, 0, 0, Money ) )
	{
		return RC::RC_ITEM_ERRORDROPMONEY;
	}

//	m_pPlayer->SetMoney( m_pPlayer->GetMoney() - Money );
	m_pPlayer->MinusMoney( Money );	// SetMoney肺 捣 静绰 何盒 傈何 MinusMoney()肺 背眉吝(泅芒)

	return RC::RC_ITEM_SUCCESS;
}

RC::eITEM_RESULT ItemManager::Drop( SLOTIDX atIndex, POSTYPE atPos )
{
	if( !ValidState() ) 
		return RC::RC_ITEM_INVALIDSTATE;

	if( !ValidPos( atIndex, atPos ) )
		return RC::RC_ITEM_INVALIDPOS;

	if( NULL == m_pPlayer->GetField() )
		return RC::RC_ITEM_INVALIDSTATEOFPLAYER;


	SCSlotContainer * pAtContainer = GetItemSlotContainer( atIndex );
	if( pAtContainer->IsEmpty( atPos ) )
	{
		return RC::RC_ITEM_EMPTYSLOT;
	}

	DEBUG_CODE( SCItemSlot & rslot = (SCItemSlot &)pAtContainer->GetSlot(atPos); rslot.GetItemInfo(); );
	SCItemSlot DropItemSlotOut;
	pAtContainer->DeleteSlot( atPos, &DropItemSlotOut );

	WzVector wvCurPos = m_pPlayer->GetRandomPosInAround(2);
	if( !g_DropManager.DropItemToField( m_pPlayer->GetField(), &wvCurPos, NULL, 0, DropItemSlotOut ) )
	{
		return RC::RC_ITEM_INVALIDPOSFORDROPITEM;
	}

	// 酒捞袍 滚府扁 肺弊(阁胶磐 靛而篮 ItemManager俊辑 窍瘤 臼绰促. ItemManager绰 坷流 敲饭捞绢狼 青悼俊父 康氢甫 尝模促.
	GAMELOG->WriteItemOwner( m_pPlayer, g_pGameServer->GetServerGUID(), FALSE, &DropItemSlotOut ); 
	// 酒捞袍 滚府扁 肺弊 场

	return RC::RC_ITEM_SUCCESS;
}

VOID ItemManager::CanInsertItem( SCSlotContainer * pContainer, POSTYPE MAX_DUP_NUM, POSTYPE & INOUT need_num, POSTYPE * OUT PosArray, POSTYPE & OUT PosNum )
{
	if( need_num == 0 ) return;
	for( POSTYPE pos = 0 ; pos < pContainer->GetMaxSlotNum() ; ++pos )
	{
		if( pContainer->IsEmpty(pos) )
		{
			PosArray[PosNum++] = pos;
			if( need_num > MAX_DUP_NUM)
				need_num -= MAX_DUP_NUM;
			else
				need_num = 0;

			if( need_num == 0 ) break;
		}
	}
}

VOID ItemManager::CanInsertOverlappedItem( SCSlotContainer * pContainer, SLOTCODE ItemCode, POSTYPE & INOUT need_num, POSTYPE * OUT PosArray, POSTYPE & OUT PosNum )
{
	if( need_num == 0 ) return;
	for( POSTYPE pos = 0 ; pos < pContainer->GetMaxSlotNum() ; ++pos )
	{
		if( !pContainer->IsEmpty(pos) )
		{
			SCItemSlot & ItemSlot = (SCItemSlot &)pContainer->GetSlot(pos);
			if( ItemSlot.GetCode() == ItemCode && ItemSlot.GetNum() < ItemSlot.GetMaxNum() )
			{
				ASSERT( ItemSlot.GetNum() != 0 );
				PosArray[PosNum++] = pos;
				if( need_num + ItemSlot.GetNum() <= ItemSlot.GetMaxNum() )
				{
					need_num = 0;
				}
				else
				{
					need_num -= (ItemSlot.GetMaxNum() - ItemSlot.GetNum());
				}
				if( need_num == 0 ) break;
			}
		}
	}
}

// [裙垫 贸府]
// 般媚瘤绰 酒捞袍俊 措秦辑
// 牧抛捞呈肺 俺荐眉农肺 火涝咯何魄窜, 弊府绊 官肺 火涝
// ex) CheckInsertItem( pInven, 3, RemainNum ); => 角菩登搁 CheckInsertItem( pTmpInven, RemainNum ); => 己傍 咯何 眉农
// 般媚瘤瘤 臼绰 酒捞袍俊 措秦辑
// 牧抛捞呈甫 老老洒 眉农窍咯 俺荐鳖瘤 备茄 促澜 火涝
// ex) 

BOOL ItemManager::CheckInsertItem( SCSlotContainer * pContainer, POSTYPE & INOUT need_num )
{
	if( 0 == need_num ) return TRUE;

	INT RemainNum = need_num - (pContainer->GetMaxSlotNum() - pContainer->GetSlotNum());
	if( RemainNum > 0 ) 
	{
		need_num = RemainNum;
		return FALSE;
	}
	need_num = 0;
	return TRUE;
}

// 般磨 荐 乐绰 酒捞袍阑 般摹扁 父栏肺 持阑 荐 乐绰啊? 酒聪促.
BOOL ItemManager::CheckInsertItemDup( SCSlotContainer * pContainer, SLOTCODE ItemCode, const INT MAX_DUP_NUM, POSTYPE & INOUT need_num, 
								  POSTYPE & OUT PosInfoNum, POS_INFO * OUT pPosInfo )
{
	PosInfoNum = 0;
	if( 0 == need_num ) return TRUE;
	// 滴锅 倒酒具茄促?
	if( MAX_DUP_NUM != 1 )
	{
		for( POSTYPE pos = 0 ; pos < pContainer->GetMaxSlotNum() ; ++pos )
		{
			if( !pContainer->IsEmpty(pos) )
			{
				SCItemSlot & ItemSlot = (SCItemSlot &)pContainer->GetSlot(pos);
				if( ItemSlot.IsOverlap() && ItemSlot.GetCode() == ItemCode && ItemSlot.GetNum() < MAX_DUP_NUM )
				{
					ASSERT( ItemSlot.GetNum() != 0 );
					pPosInfo[PosInfoNum].m_pos = pos;	
					if( need_num + ItemSlot.GetNum() <= MAX_DUP_NUM )
					{
						pPosInfo[PosInfoNum].m_num = need_num;
						need_num = 0;
					}
					else
					{
						pPosInfo[PosInfoNum].m_num = (MAX_DUP_NUM - ItemSlot.GetNum());
						need_num -= pPosInfo[PosInfoNum].m_num;
					}
					++PosInfoNum;
					if( need_num == 0 ) return TRUE;
				}
			}
		}
	}
	ASSERT( need_num != 0 );
	for( POSTYPE pos = 0 ; pos < pContainer->GetMaxSlotNum() ; ++pos )
	{
		if( pContainer->IsEmpty(pos) )
		{
			pPosInfo[PosInfoNum].m_pos = pos;
			if( need_num > MAX_DUP_NUM)
			{
				pPosInfo[PosInfoNum].m_num = MAX_DUP_NUM;
				need_num -= MAX_DUP_NUM;
			}