itemdrop.cpp

墨香最新私服

// ItemDrop.cpp: implementation of the CItemDrop class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ItemDrop.h"
#include "Player.h"
#include "time.h"
#include "ItemManager.h"
#include "Monster.h"
#include "..\[CC]Header\GameResourceManager.h"
#include "MHFile.h"
#include "PartyManager.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CItemDrop::CItemDrop()
{
	m_MonsterItemDropTable.Initialize(64);
}

CItemDrop::~CItemDrop()
{
	ClearMonsterDropItemList();
}

void CItemDrop::Init()
{
	srand((unsigned)time(NULL));
	LoadMonsterDropItemList();
}
void CItemDrop::ReloadDropItem(MONSTEREX_LIST * pMonsterExList)
{
	WORD TotalRate = 0;
	for(int n=0;n<eDROPITEMKIND_MAX;++n)
	{
		ASSERT(pMonsterExList->CurDropRate[n] == 0);
		pMonsterExList->CurDropRate[n] = pMonsterExList->DropRate[n];
		TotalRate += pMonsterExList->DropRate[n];
	}

}

int CItemDrop::DropItemKind(MONSTEREX_LIST * pMonsterExList)
{
	DWORD CurTotalRate = 0;
	DWORD DropRate[eDROPITEMKIND_MAX];
	DWORD TempDropRate[eDROPITEMKIND_MAX];

	for(int i=0; i<eDROPITEMKIND_MAX; i++)
	{
		DropRate[i] = pMonsterExList->CurDropRate[i];
		TempDropRate[i] = pMonsterExList->CurDropRate[i];
		if(i == eMONEY)
			DropRate[eMONEY] *= gMoneyRate;
		else if(i >= eITEM1 && i <= eITEM3)
			DropRate[i] *= gItemRate;

		CurTotalRate += DropRate[i];	
	}


	if(CurTotalRate == 0)
	{
		CurTotalRate = 0;
		ReloadDropItem(pMonsterExList);

		for( i=0; i<eDROPITEMKIND_MAX; i++)
		{
			DropRate[i] = pMonsterExList->CurDropRate[i];
			TempDropRate[i] = pMonsterExList->CurDropRate[i];
			if(i == eMONEY)
				DropRate[eMONEY] *= gMoneyRate;
			else if(i >= eITEM1 && i <= eITEM3)
				DropRate[i] *= gItemRate;

			CurTotalRate += DropRate[i];	
		}
	}


	// RaMa -04.11.24  ->靛而啦荐沥
	if( CurTotalRate > MAX_DROP_ITEM_PERCENT )
	{		
		int dwTemp = MAX_DROP_ITEM_PERCENT - (DropRate[eMONEY]+DropRate[eITEM1]+DropRate[eITEM2]+DropRate[eITEM3]);
		if( dwTemp > 0 )
		{
			DropRate[eNOITEM] = dwTemp;
			CurTotalRate = MAX_DROP_ITEM_PERCENT;
		}
		else
		{
			DropRate[eNOITEM] = 0;
			CurTotalRate = DropRate[eMONEY]+DropRate[eITEM1]+DropRate[eITEM2]+DropRate[eITEM3];
		}
	}


	DWORD RandRate = random(0, CurTotalRate);
	DWORD CurMinRate=0,CurMaxRate=0;

	for( i=0; i<eDROPITEMKIND_MAX; i++)
	{
		CurMinRate = CurMaxRate;
		CurMaxRate += DropRate[i];
		if(RandRate >= CurMinRate && RandRate < CurMaxRate)
		{
			ASSERT(DropRate[i] != 0);
			return i;
		}
	}
	ASSERT(0);
	return -1;


/*
	WORD* CurRate = pMonsterExList->CurDropRate;

	WORD CurTotalRate=0;
	for(int n=0;n<eDROPITEMKIND_MAX;++n)
		CurTotalRate += CurRate[n];

	if(CurTotalRate == 0)
	{
		CurTotalRate = 0;
		ReloadDropItem(pMonsterExList);
		for(int n=0;n<eDROPITEMKIND_MAX;++n)
			CurTotalRate += CurRate[n];
	}
	
	--CurTotalRate;	

	WORD RandRate = random( 0, CurTotalRate );

	WORD CurMinRate=0,CurMaxRate=0;
	for(n=0;n<eDROPITEMKIND_MAX;++n)
	{
		CurMinRate = CurMaxRate;
		CurMaxRate += CurRate[n];
		if(CurMinRate <= RandRate && RandRate < CurMaxRate)
		{
			ASSERT(CurRate[n] != 0);
			--CurRate[n];
			return n;
		}
	}
	ASSERT(0);
	return -1;
*/
}
MONEYTYPE CItemDrop::MoneyItemNoItemPercentCalculator(MONSTEREX_LIST * pMonInfo, CPlayer* pPlayer, WORD MonsterKind)
{
//	ASSERT(pMob->GetObjectKind() & eObjectKind_Monster );

	int eDropItemKind = DropItemKind(pMonInfo);
	switch(eDropItemKind)
	{
	case eNOITEM:
		{

		}
		break;
	case eMONEY:
		{
			return MonsterDropMoney(pMonInfo);
		/*	if( pPlayer->SetMoney(Money, MONEY_ADDITION, 1, eItemTable_Inventory, eMoneyLog_GetMonster, pMob->GetID()) != Money )
			{
				// error msg 焊辰促. 力茄樊 檬苞
				MSGBASE msg;
				msg.Category = MP_ITEM;
				msg.Protocol = MP_ITEM_MONEY_ERROR;
				msg.dwObjectID = pPlayer->GetID();

				pPlayer->SendMsg(&msg, sizeof(msg));
			}
			*/
		}
		break;
	case eITEM1:
		{
			MonsterDropItem(MonsterKind, pMonInfo->ItemListNum1, pPlayer);
		}
		break;
	case eITEM2:
		{
			MonsterDropItem(MonsterKind, pMonInfo->ItemListNum2, pPlayer);
		}
		break;
	case eITEM3:
		{
			MonsterDropItem(MonsterKind, pMonInfo->ItemListNum3, pPlayer);
		}
		break;
	default:
		{
			ASSERT(0);
		}
	}
	return 0;
}

MONEYTYPE CItemDrop::MonsterDropMoney(MONSTEREX_LIST * pMonsterExList)
{
	MONEYTYPE MinMoney = pMonsterExList->MinDropMoney;
	MONEYTYPE MaxMoney = pMonsterExList->MaxDropMoney;
	ASSERT(MaxMoney >= MinMoney);

	MONEYTYPE ResultMoney = 0;

	if(MinMoney == MaxMoney)
	{
		ResultMoney =MinMoney;
	}
	else
		ResultMoney = (rand() % (MaxMoney - MinMoney)) + MinMoney;
	
	// RaMa -04.11.24   ->捣 掘绰 咀荐
	ResultMoney *= gGetMoney;

	return ResultMoney;
}

void CItemDrop::MonsterDropItem(WORD MonsterKind, WORD wDropItemIdx, CPlayer* pPlayer)
{
	MONSTER_DROP_ITEM * pDropItem = GetMonsterItemDrop(wDropItemIdx);
	ASSERT(pDropItem);
	if(pDropItem == NULL)
		return;
	
	if( pDropItem->wCurTotalRate == 0 )
	{
		// yh 酒捞袍阑 靛而窍瘤 臼绰 版快(TotalRate 啊 0)俊 FALSE 府畔
		if(ReloadMonsterDropItem(pDropItem) == FALSE)
			return;
	}

	WORD RandRate = random( 0, pDropItem->wCurTotalRate );
	
	WORD FromPercent	= 0;
	WORD ToPercent		= 0;

	for(WORD i = 0 ; i < pDropItem->wTotalNum ; ++i)
	{
		FromPercent = ToPercent;
		ToPercent += pDropItem->CurMonsterDropItemPercent[i];
		if(FromPercent <= RandRate && RandRate < ToPercent)
		{
			ASSERT(pDropItem->CurMonsterDropItemPercent[i]!=0);
			ASSERT(pDropItem->wCurTotalRate!=0);
			--pDropItem->CurMonsterDropItemPercent[i];
			--pDropItem->wCurTotalRate;

			if(pDropItem->MonsterDropItemPercent[i].wItemIdx)
				ITEMMGR->MonsterObtainItem(pPlayer, pDropItem->MonsterDropItemPercent[i].wItemIdx, MonsterKind);

			break;
		}
	}

}


BOOL CItemDrop::ReloadMonsterDropItem(MONSTER_DROP_ITEM* pDropItem)
{
	WORD HaveItem = pDropItem->wTotalNum;

	pDropItem->wCurTotalRate = 0;
	for(WORD i = 0; i < HaveItem; ++i)
	{
		pDropItem->CurMonsterDropItemPercent[i] = pDropItem->MonsterDropItemPercent[i].DropPercent;
		pDropItem->wCurTotalRate += pDropItem->CurMonsterDropItemPercent[i];
	}
	if(pDropItem->wCurTotalRate == 0)
		return FALSE;

	return TRUE;
}


void CItemDrop::ClearMonsterDropItemList()
{
	// reset data
	m_MonsterItemDropTable.SetPositionHead();
	MONSTER_DROP_ITEM* pDropItem;
	while(pDropItem = m_MonsterItemDropTable.GetData())
	{
		delete pDropItem;
	}
	m_MonsterItemDropTable.RemoveAll();
}

BOOL CItemDrop::LoadMonsterDropItemList()
{
	ClearMonsterDropItemList();

	char filename[64];
	CMHFile file;
#ifdef _FILE_BIN_
	sprintf(filename,"./Resource/MonsterDropItemList.bin");	
	if(!file.Init(filename, "rb"))
		return FALSE;
#else
	sprintf(filename,"./Resource/MonsterDropItemList.txt");	
	if(!file.Init(filename, "rt"))
		return FALSE;
#endif

	while(1)
	{
		if(file.IsEOF())
			break;
		
		MONSTER_DROP_ITEM* pDropItem = new MONSTER_DROP_ITEM;
		memset(pDropItem, 0, sizeof(MONSTER_DROP_ITEM));
		pDropItem->wItemDropIndex = file.GetWord();// 佬扁父 茄促.

		WORD totalnum = 0;
		for(int idx=0; idx<MAX_DROPITEM_NUM; ++idx)
		{
#ifdef _DEBUG
			file.GetString(pDropItem->MonsterDropItemPercent[idx].Name);
			pDropItem->MonsterDropItemPercent[idx].wItemIdx = file.GetWord();		
			pDropItem->MonsterDropItemPercent[idx].DropPercent = file.GetWord();
			if(pDropItem->MonsterDropItemPercent[idx].wItemIdx)
				++totalnum;
#else
			char szTempName[256];
			file.GetString(szTempName);
			pDropItem->MonsterDropItemPercent[idx].wItemIdx = file.GetWord();		
			pDropItem->MonsterDropItemPercent[idx].DropPercent = file.GetWord();
			if(pDropItem->MonsterDropItemPercent[idx].wItemIdx)
				++totalnum;
#endif
		}
		
		pDropItem->wTotalNum = totalnum;
		pDropItem->wCurTotalRate = 0;

		ASSERT(!m_MonsterItemDropTable.GetData(pDropItem->wItemDropIndex));
		m_MonsterItemDropTable.Add(pDropItem,pDropItem->wItemDropIndex);

		ReloadMonsterDropItem(pDropItem);
	}	
	
	return TRUE;
}

MONSTER_DROP_ITEM* CItemDrop::GetMonsterItemDrop(WORD wItemDropIdx)
{
	return m_MonsterItemDropTable.GetData(wItemDropIdx);
}

//////////////////////////////////////////////////////////////////////////
// test
// old code 
/*


void CItemDrop::TestMonsterDropItem(WORD wDropItemListIdx)
{
	int Kind = wDropItemListIdx;
	
	MONSTER_ITEM_DROP* pDropItem = GetMonsterItemDrop(Kind);
	int HaveItem = pDropItem->m_MonsterDropTotalNum;	
	int MaxDropNum = 0;
	int DropNum = 0;
	int DropPercent = 0;
	int CurPercent = 0;
	int TempPercent = 0;
	
	int VarMaxPercent = pDropItem->m_MonsterMaxVarPercent; // 盒葛
	if(!VarMaxPercent)
		return;

	DropNum = 1;
	for(int i = 0; i < DropNum; i++)
	{
		CurPercent = 0;
		TempPercent = 0;
		DropPercent = rand() % VarMaxPercent; // 冻绢哆副 犬伏
		if(!DpPercent)
			DropPercent = 1;
		for(int j=0; j<HaveItem; j++)
		{
			CurPercent = pDropItem->m_MonsterDropItemVarPercent[j].DropPercent;
			if(!CurPercent)	// 欺季飘啊 0捞搁 Zero眉农饶 Reload
			{
				BOOL flag = ZeroCheckPercent(Kind);
				if(flag)
				{
					ReloadDropItemPercent(Kind); // 葛滴 0捞搁 犁面傈
					
					FILE* fp = fopen("itemdroptest.txt","a+");
					fprintf(fp,"ReloadDropItemPercent\n",pDropItem->m_MonsterDropItemVarPercent[j].Name,
						pDropItem->m_MonsterDropItemVarPercent[j].ItemIdx);
					
					
					fclose(fp);
				}
			}
			else if(TempPercent<DropPercent && TempPercent+CurPercent>=DropPercent)
			{
				// 犬伏俊 甸绢吭栏骨肺 靛酚
				MONSTER_ITEM tmp;
				WORD HuntItemNum = pDropItem->m_MonsterDropItemVarPercent[j].ItemIdx;
				tmp = pDropItem->m_MonsterDropItemVarPercent[j];
				if(HuntItemNum == 0) 
					return;
				ASSERT(HuntItemNum != 52685);
				FILE* fp = fopen("itemdroptest.txt","a+");
				fprintf(fp,"item : %s (%d)\n",pDropItem->m_MonsterDropItemVarPercent[j].Name,
											pDropItem->m_MonsterDropItemVarPercent[j].ItemIdx);
				

				fclose(fp);
				
				CalculItemPercent(Kind, HaveItem, j);
			}
			TempPercent = TempPercent+CurPercent;
		}
		
	}
}
*/
//////////////////////////////////////////////////////////////////////////


/*
void CItemDrop::CalculItemPercent(WORD Kind, int HaveItem, int idx)
{
	MONSTER_ITEM_DROP* pDropItem = GetMonsterItemDrop(Kind);

	int VarPercent = 0;
	int tmpPercent = pDropItem->m_MonsterDropItemVarPercent[idx].DropPercent;
	int VarMaxPercent = pDropItem->m_MonsterMaxVarPercent; // 盒葛
	if(tmpPercent)
	{
		for(int i = 0; i < HaveItem; i++)
		{
			VarPercent = pDropItem->m_MonsterDropItemVarPercent[i].DropPercent;
			if(!VarPercent)
			{
				pDropItem->m_MonsterDropItemVarPercent[i].DropPercent = VarPercent;
				continue;
			}
			if(!VarMaxPercent)
				ReloadDropItemPercent(Kind); // 0捞搁 犁面傈
			if(i == idx)
			{
				pDropItem->m_MonsterDropItemVarPercent[i].DropPercent = VarPercent-1;
				pDropItem->m_MonsterMaxVarPercent = VarMaxPercent-1;
			}
		}
		// 葛电 欺季飘啊 0牢瘤 八荤
		BOOL flag = ZeroCheckPercent(Kind);
		if(flag)
			ReloadDropItemPercent(Kind); // 葛滴 0捞搁 犁面傈
	}
	else
	{
		// 咯扁俊 吧府搁 俊矾扼匙
		BOOL flag = ZeroCheckPercent(Kind);
		if(flag)
			ReloadDropItemPercent(Kind); // 葛滴 0捞搁 犁面傈
	}
}

BOOL CItemDrop::ZeroCheckPercent(WORD Kind)
{
	MONSTER_ITEM_DROP* pDropItem = GetMonsterItemDrop(Kind);

	int tmpPercent[MAX_DROPITEM_NUM];
	int AddPercent = 0;
	for(int i = 0; i < MAX_DROPITEM_NUM; i++)
	{
		tmpPercent[i] = pDropItem->m_MonsterDropItemVarPercent[i].DropPercent;
		AddPercent = AddPercent + tmpPercent[i];
	}

	if(AddPercent) // 欺季飘 穿利狼 钦捞 0捞搁 傈何 0烙
		return FALSE;  // Reload 窍扼绊 瘤矫
	else
		return TRUE;
}
*/