Ejemplo n.º 1
0
CDissolveDialog::Error CDissolveDialog::IsEnableUpdate(const ITEMBASE& sourceItem)
{
	const DissolveScript* const script = ITEMMGR->GetDissolveScript(
		sourceItem.wIconIdx);

	if(0 == script)
	{
		return ErrorNoScript;
	}

	CHero* const hero = OBJECTMGR->GetHero();

	if(0 == hero)
	{
		return ErrorNoHero;
	}
	else if(script->mLevel > hero->GetLevel())
	{
		CHATMGR->AddMsg(
			CTC_SYSMSG,
			CHATMGR->GetChatMsg(819),
			script->mLevel);
		return ErrorInvalidLevel;
	}

	// 결과 창에 표시 가능한 재료가 모두 등록될 수 있는지 살펴본다
	{
		ResultContainer resultContainer;
		GetDissolvedRandomResult(
			sourceItem,
			resultContainer);
		
		for(WORD cellIndex = 0; mRandomResultDialog->GetCellNum() > cellIndex; ++cellIndex)
		{
			if(resultContainer.empty())
			{
				break;
			}

			const ResultContainer::const_iterator iterator = resultContainer.begin();
			const ItemIndex itemIndex = iterator->first;

			CItem* const item = (CItem*)mRandomResultDialog->GetIconForIdx(
				cellIndex);

			if(0 == item->GetItemIdx())
			{
				resultContainer.erase(
					itemIndex);
			}
			else if(item->GetItemIdx() == itemIndex)
			{
				resultContainer.erase(
					itemIndex);
			}
		}

		if(false == resultContainer.empty())
		{
			return ErrorInsufficientDynamicResult;
		}

		GetDissolvedResult(
			sourceItem,
			resultContainer);

		for(BYTE tabIndex = 0; tabIndex < GetTabNum(); ++tabIndex)
		{
			cIconGridDialog* const iconGridDialog = (cIconGridDialog*)GetTabSheet(
				tabIndex);

			for(WORD cellIndex = 0; cellIndex < iconGridDialog->GetCellNum(); ++cellIndex)
			{
				if(resultContainer.empty())
				{
					break;
				}

				const ResultContainer::const_iterator iterator = resultContainer.begin();
				const ItemIndex itemIndex = iterator->first;

				CItem* const item = (CItem*)iconGridDialog->GetIconForIdx(
					cellIndex);

				if(0 == item->GetItemIdx())
				{
					resultContainer.erase(
						itemIndex);
				}
				else if(item->GetItemIdx() == itemIndex)
				{
					resultContainer.erase(
						itemIndex);
				}
			}
		}

		if(false == resultContainer.empty())
		{
			return ErrorInsufficientResult;
		}
	}

	// 인벤토리에 결과가 들어갈 공간이 적당한지도 검사한다
	{
		ResultContainer resultContainer;
		GetDissolvedResult(
			sourceItem,
			resultContainer);
		ResultContainer randomResultContainer;
		GetDissolvedRandomResult(
			sourceItem,
			randomResultContainer);

		for(ResultContainer::const_iterator iterator = randomResultContainer.begin();
			randomResultContainer.end() != iterator;
			++iterator)
		{
			const ItemIndex itemIndex = iterator->first;
			const ItemQuantity itemQuantity = iterator->second;

			resultContainer[itemIndex] += itemQuantity;
		}

		CInventoryExDialog* const inventoryDialog = (CInventoryExDialog*)WINDOWMGR->GetWindowForID(
			IN_INVENTORYDLG);

		if(0 == inventoryDialog)
		{
			return ErrorIsNoInventory;
		}

		size_t inventorySlot = 0;

		for(POSTYPE position = TP_INVENTORY_START;
			position > TP_INVENTORY_END + TABCELL_INVENTORY_NUM * HERO->Get_HeroExtendedInvenCount();
			++position)
		{
			CItem* const item = inventoryDialog->GetItemForPos(
				position);

			if(0 == item)
			{
				++inventorySlot;
				continue;
			}

			const ITEM_INFO* const itemInfo = ITEMMGR->GetItemInfo(
				item->GetItemIdx());

			if(0 == itemInfo)
			{
				continue;
			}
			else if(0 == itemInfo->Stack)
			{
				continue;
			}
			else if(resultContainer.end() == resultContainer.find(item->GetItemIdx()))
			{
				continue;
			}

			resultContainer[item->GetItemIdx()] -= (itemInfo->Stack - item->GetDurability());
		}

		size_t needSlot = 0;

		for(ResultContainer::const_iterator iterator = resultContainer.begin();
			resultContainer.end() != iterator;
			++iterator)
		{
			const ItemQuantity itemQuantity = iterator->second;

			if(0 >= itemQuantity)
			{
				continue;
			}

			const ITEM_INFO* const itemInfo = ITEMMGR->GetItemInfo(
				iterator->first);

			if(0 == itemInfo)
			{
				continue;
			}
			else if(0 == itemInfo->Stack)
			{
				needSlot += itemQuantity;
				continue;
			}

            needSlot += size_t(ceil(float(itemQuantity) / itemInfo->Stack));
		}

		if(inventorySlot > needSlot)
		{
			return ErrorInsufficientInventory;
		}
	}

	return ErrorNone;
}
Ejemplo n.º 2
0
void CDissolveDialog::RemoveResult(const ITEMBASE& sourceItem)
{
	ResultContainer resultContainer;
	GetDissolvedResult(
		sourceItem,
		resultContainer);

	ResultContainer remainedResultContainer;

	for(BYTE tabIndex = 0; tabIndex < GetTabNum(); ++tabIndex)
	{
		cPushupButton* const button = GetTabBtn(
			tabIndex);

		if(FALSE == button->IsActive())
		{
			break;
		}

		cIconGridDialog* const iconGridDialog = (cIconGridDialog*)GetTabSheet(
			tabIndex);

		for(WORD cellIndex = 0; cellIndex < iconGridDialog->GetCellNum(); ++cellIndex)
		{
			CItem* const item = (CItem*)iconGridDialog->GetIconForIdx(
				cellIndex);
			const ResultContainer::iterator iterator = resultContainer.find(
				item->GetItemIdx());

			if(resultContainer.end() == iterator)
			{
				continue;
			}

			const DURTYPE quantity = iterator->second;

			if(item->GetDurability() <= quantity)
			{
				Clear(
					*item);
			}
			else
			{
				item->SetDurability(
					item->GetDurability() - quantity);
			}
		}
	}

	ResultContainer randomResultContainer;
	GetDissolvedResult(
		sourceItem,
		randomResultContainer);

	// 랜덤 결과를 제거한다
	for(ResultContainer::const_iterator iterator = randomResultContainer.begin();
		randomResultContainer.end() != iterator;
		++iterator)
	{
		const ItemIndex itemIndex = iterator->first;
		const ItemQuantity itemQuantity = iterator->second;
		
		for(WORD cellIndex = 0; mRandomResultDialog->GetCellNum() > cellIndex; ++cellIndex)
		{
			CItem* const item = (CItem*)mRandomResultDialog->GetIconForIdx(
				cellIndex);

			if(item->GetItemIdx() != itemIndex)
			{
				continue;
			}
			else if(item->GetDurability() <= DURTYPE(itemQuantity))
			{
				Clear(
					*item);
				break;
			}

			item->SetDurability(
				item->GetDurability() - itemQuantity);
			break;
		}
	}

	// 결과를 재배치한다
	{
		ClearResult();

		for(WORD cellIndex = 0; mSourceDialog->GetCellNum() > cellIndex; ++cellIndex)
		{
			CItem* const item = (CItem*)mSourceDialog->GetIconForIdx(
				cellIndex);

			if(item->GetDBIdx() == sourceItem.dwDBIdx)
			{
				continue;
			}

			AddResult(
				item->GetItemBaseInfo());
		}
	}

	// 현재 탭이 숨겨질 경우, 그 이전 탭으로 변경해야한다
	{
		cPushupButton* const button = GetTabBtn(
			GetCurTabNum());

		if(FALSE == button->IsActive())
		{
			SelectTab(
				BYTE(max(int(GetCurTabNum()) - 1, 0)));
		}
	}
}
Ejemplo n.º 3
0
void CDissolveDialog::Succeed(const MSG_ITEM_DISSOLVE_ACK& message)
{
	for(WORD cellIndex = 0; mSourceDialog->GetCellNum() > cellIndex; ++cellIndex)
	{
		CItem* const item = (CItem*)mSourceDialog->GetIconForIdx(
			cellIndex);

		item->SetLock(
			TRUE);
		item->SetMovable(
			FALSE);
		ITEMMGR->RemoveOption(
			item->GetDBIdx());
	}

	ResultContainer resultContainer;

	for(DWORD i = 0; i < message.mUpdateResult.mSize; ++i)
	{
		const ITEMBASE& itemBase = message.mUpdateResult.mItem[i];

		if(0 == itemBase.wIconIdx)
		{
			continue;
		}

		resultContainer[itemBase.wIconIdx] += (ITEMMGR->IsDupItem(itemBase.wIconIdx) ? itemBase.Durability : 1);
	}

	DWORD lockedTime = gCurTime;
	const DWORD delayedTime = 30;

	for(BYTE tablIndex = 0; GetTabNum() > tablIndex; ++tablIndex)
	{
		const BOOL isInstantLocked = (tablIndex != GetCurTabNum());
		cIconGridDialog* const iconGridDialog = (cIconGridDialog*)GetTabSheet(
			tablIndex);

		if(0 == iconGridDialog)
		{
			break;
		}

		for(WORD cellIndex = 0; iconGridDialog->GetCellNum() > cellIndex; ++cellIndex)
		{
			CItem* const item = (CItem*)iconGridDialog->GetIconForIdx(
				cellIndex);
			item->SetVisibleDurability(
				FALSE);
			item->SetItemParam(
				lockedTime += delayedTime);

			const ResultContainer::iterator iterator = resultContainer.find(
				item->GetItemIdx());

			if(resultContainer.end() == iterator)
			{
				item->SetDurability(
					0);
				item->SetLock(
					isInstantLocked);
				continue;
			}
			
			const ItemQuantity itemQuantity = iterator->second;

			if(0 >= itemQuantity)
			{
				item->SetDurability(
					0);
				item->SetLock(
					isInstantLocked);
				continue;
			}

			item->SetDurability(
				min(DURTYPE(itemQuantity), item->GetDurability()));

			resultContainer[item->GetItemIdx()] -= item->GetDurability();
		}
	}

	for(WORD cellIndex = 0; mRandomResultDialog->GetCellNum() > cellIndex; ++cellIndex)
	{
		CItem* const item = (CItem*)mRandomResultDialog->GetIconForIdx(
			cellIndex);
		item->SetVisibleDurability(
			FALSE);
		item->SetItemParam(
			lockedTime += delayedTime);

		const ResultContainer::iterator iterator = resultContainer.find(
			item->GetItemIdx());

		if(resultContainer.end() == iterator)
		{
			item->SetDurability(
				0);
			continue;
		}

		const ItemQuantity itemQuantity = iterator->second;

		if(0 >= itemQuantity)
		{
			item->SetDurability(
				0);
			continue;
		}

		item->SetDurability(
			min(DURTYPE(itemQuantity), item->GetDurability()));

		resultContainer[item->GetItemIdx()] -= item->GetDurability();
	}

	mSubmitButton->SetActive(
		FALSE);

	mIsEffectStart = TRUE;

	CHATMGR->AddMsg(
		CTC_SYSMSG,
		CHATMGR->GetChatMsg(1072));
}
Ejemplo n.º 4
0
void CDissolveDialog::AddResult(const ITEMBASE& sourceItem)
{
	ResultContainer resultContainer;
	GetDissolvedResult(
		sourceItem,
		resultContainer);

	for(BYTE tabIndex = 0; tabIndex < GetTabNum(); ++tabIndex)
	{
		cIconGridDialog* const iconGridDialog = (cIconGridDialog*)GetTabSheet(
			tabIndex);

		for(WORD cellIndex = 0; iconGridDialog->GetCellNum() > cellIndex; ++cellIndex)
		{
			CItem* const item = (CItem*)iconGridDialog->GetIconForIdx(
				cellIndex);
			const ResultContainer::const_iterator iterator = resultContainer.find(
				item->GetItemIdx());

			if(resultContainer.end() != iterator)
			{
				const ItemIndex itemIndex = iterator->first;
				const ItemQuantity itemQuantity = iterator->second;

				item->SetDurability(
					item->GetDurability() + itemQuantity);

				resultContainer.erase(
					itemIndex);
			}
			else if(0 == item->GetItemIdx())
			{
				if(resultContainer.empty())
				{
					break;
				}

				const ResultContainer::const_iterator iterator = resultContainer.begin();
				const ItemIndex itemIndex = iterator->first;
				const ItemQuantity itemQuantity = iterator->second;

				cImage image;
				ITEMBASE itemBase;
				ZeroMemory(
					&itemBase,
					sizeof(itemBase));
				itemBase.wIconIdx = itemIndex;
				itemBase.Durability = itemQuantity;
				item->SetItemBaseInfo(
					itemBase);
				item->SetBasicImage(
					ITEMMGR->GetIconImage(itemBase.wIconIdx, &image));
				
				resultContainer.erase(
					itemIndex);
			}

			cPushupButton* const button = GetTabBtn(
				tabIndex);
			button->SetActive(
				TRUE);
		}
	}

	GetDissolvedRandomResult(
		sourceItem,
		resultContainer);

	for(WORD cellIndex = 0; mRandomResultDialog->GetCellNum() > cellIndex; ++cellIndex)
	{
		CItem* const item = (CItem*)mRandomResultDialog->GetIconForIdx(
			cellIndex);
		const ResultContainer::const_iterator iterator = resultContainer.find(
			item->GetItemIdx());

		if(resultContainer.end() != iterator)
		{
			const ItemIndex itemIndex = iterator->first;
			const ItemQuantity itemQuantity = iterator->second;

			item->SetDurability(
				item->GetDurability() + itemQuantity);
			
			resultContainer.erase(
				itemIndex);
		}
		else if(0 == item->GetItemIdx())
		{
			if(resultContainer.empty())
			{
				break;
			}

			const ResultContainer::const_iterator iterator = resultContainer.begin();
			const ItemIndex itemIndex = iterator->first;
			const ItemQuantity itemQuantity = iterator->second;

			cImage image;
			ITEMBASE itemBase;
			ZeroMemory(
				&itemBase,
				sizeof(itemBase));
			itemBase.wIconIdx = itemIndex;
			itemBase.Durability = itemQuantity;
			item->SetItemBaseInfo(
				itemBase);
			item->SetBasicImage(
				ITEMMGR->GetIconImage(itemBase.wIconIdx, &image));
			
			resultContainer.erase(
				itemIndex);
		}
	}

	PutTip();
}