fast Upgrade system

[aladinia]

Hello i release a Fast Upgrade system credits idk. i found it on other source and the tutorial for add on lodelight from Xenus

DPClient.cpp
Search :

 Spoiler

void CDPClient::OnSmeltSafety( CAr & ar )

Replace that :

 Spoiler

BYTE nResult = 0;
ar >> nResult;

CWndSmeltSafety* pWndSmeltSafety = g_WndMng.m_pWndSmeltSafety;
if (pWndSmeltSafety == NULL)
return;

switch (nResult)
{
case 0: // ¾ÈÀü �¦·Ã: À߸øµÈ Àç·á¸¦ µî·�ÇßÀ» ¶§
break;
case 1: // ¾ÈÀü �¦·Ã: �¦·Ã ¼º°øÇßÀ» ¶§
{
int nCurrentSmeltNumber(pWndSmeltSafety->GetCurrentSmeltNumber());
pWndSmeltSafety->SetResultStatic(true, nCurrentSmeltNumber);
pWndSmeltSafety->SetCurrentSmeltNumber(++nCurrentSmeltNumber);
pWndSmeltSafety->RefreshInformation();
pWndSmeltSafety->DisableScroll2();
pWndSmeltSafety->SetResultSwitch(true);

break;
}
case 2: // ¾ÈÀü �¦·Ã: �¦·Ã ½ÇÆ�ÇßÀ» ¶§
{
int nCurrentSmeltNumber(pWndSmeltSafety->GetCurrentSmeltNumber());
pWndSmeltSafety->SetResultStatic(false, nCurrentSmeltNumber);
pWndSmeltSafety->SetCurrentSmeltNumber(++nCurrentSmeltNumber);
pWndSmeltSafety->RefreshValidSmeltCounter();
pWndSmeltSafety->SetResultSwitch(true);
break;
}
case 3:
break;
}

With :

 Spoiler

void CDPClient::OnSmeltSafety( CAr & ar )
{
BYTE nResult = 0;
ar >> nResult;


#ifdef _FAST_UPGRADE_SYSTEM
if (g_WndMng.m_pWndFastUpgrade)
g_WndMng.m_pWndFastUpgrade->OnResult(nResult);
#else
CWndSmeltSafety* pWndSmeltSafety = g_WndMng.m_pWndSmeltSafety;
if (pWndSmeltSafety == NULL)
return;

switch (nResult)
{
case 0: // ¾ÈÀü �¦·Ã: À߸øµÈ Àç·á¸¦ µî·�ÇßÀ» ¶§
break;
case 1: // ¾ÈÀü �¦·Ã: �¦·Ã ¼º°øÇßÀ» ¶§
{
int nCurrentSmeltNumber(pWndSmeltSafety->GetCurrentSmeltNumber());
pWndSmeltSafety->SetResultStatic(true, nCurrentSmeltNumber);
pWndSmeltSafety->SetCurrentSmeltNumber(++nCurrentSmeltNumber);
pWndSmeltSafety->RefreshInformation();
pWndSmeltSafety->DisableScroll2();
pWndSmeltSafety->SetResultSwitch(true);

break;
}
case 2: // ¾ÈÀü �¦·Ã: �¦·Ã ½ÇÆ�ÇßÀ» ¶§
{
int nCurrentSmeltNumber(pWndSmeltSafety->GetCurrentSmeltNumber());
pWndSmeltSafety->SetResultStatic(false, nCurrentSmeltNumber);
pWndSmeltSafety->SetCurrentSmeltNumber(++nCurrentSmeltNumber);
pWndSmeltSafety->RefreshValidSmeltCounter();
pWndSmeltSafety->SetResultSwitch(true);
break;
}
case 3:
break;
}
#endif

DPSrvr.cpp
Search :

 Spoiler

#if __VER >= 14 // __SMELT_SAFETY
void CDPSrvr::OnSmeltSafety( CAr & ar, DPID dpidCache, DPID dpidUser, LPBYTE lpBuf, u_long uBufSize)
{
OBJID dwItemId, dwItemMaterialId, dwItemProtScrId, dwItemSmeltScrId;

// pItemSmeltScrId - À�¹��¦·Ã½ÃÀÇ �¦·ÃµÎ·ç¸¶¸®(»ç¿ë¾ÈÇҽÿ£ Client¿¡¼ NULL_ID¸¦ ÀÔ·Â)
ar >> dwItemId >> dwItemMaterialId >> dwItemProtScrId >> dwItemSmeltScrId;

CUser* pUser = g_UserMng.GetUser( dpidCache, dpidUser );

if( IsValidObj( pUser ) )
{

Add below :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
if (!CNpcChecker::GetInstance()->IsCloseNpc(MMI_FASTUPGRADE, pUser->GetWorld(), pUser->GetPos()))
return;
#endif

Create 2 new file WndFastUpgrade.cpp and .h
In .cpp file add :

 Spoiler

#include "StdAfx.h"
#include "WndFastUpgrade.h"
#include "DPClient.h"
extern CDPClient g_DPlay;
#include "ResData.h"
#include "defineText.h"

#ifdef _FAST_UPGRADE_SYSTEM
CWndFastUpgrade::CWndFastUpgrade()
{
m_lpTargetItem = NULL;
m_lpRefineItem = NULL;
m_lpProtectItem = NULL;
m_lpChanceItem = NULL;
m_lpTriesBG = NULL;

m_pTargetItem = nullptr;
m_pRefineItem = nullptr;
m_pProtectItem = nullptr;
m_pChanceItem = nullptr;

m_nWantedUpgrade = 0;

m_pTexMoonStone = nullptr;
m_pTexAProtect = nullptr;
m_pTexSProtect = nullptr;
m_pTexGProtect = nullptr;
m_pTexUSProtect = nullptr;

m_pWndWantedUpgrade = nullptr;
m_pWndCost = nullptr;

m_bIsUpgrading = false;
m_bResultSwitch = false;

m_nMax = 0;
m_nSelect = -1;

m_pVertexBufferGauge = nullptr;
m_pNowGaugeTexture = nullptr;
}

CWndFastUpgrade::~CWndFastUpgrade()
{
if (m_pTargetItem)
m_pTargetItem->SetExtra(NULL);
if (m_pRefineItem)
m_pRefineItem->SetExtra(NULL);
if (m_pProtectItem)
m_pProtectItem->SetExtra(NULL);
if (m_pChanceItem)
m_pChanceItem->SetExtra(NULL);
}

void CWndFastUpgrade::FinishUpgrade()
{
m_bIsUpgrading = false;
m_bResultSwitch = false;
}

BOOL CWndFastUpgrade::Process()
{

if (g_pPlayer == nullptr)
return FALSE;

if (m_bIsUpgrading == false)
return FALSE;

if (m_bResultSwitch != false)
{
m_fGaugeRate = static_cast<float>(g_tmCurrent - m_dwEnchantTimeStart) / static_cast<float>(m_dwEnchantTimeEnd - m_dwEnchantTimeStart);
}
else
{
m_fGaugeRate = 0.0f;
}

if (GetTargetItemUpgrade() >= m_nWantedUpgrade)
{
FinishUpgrade();
}

if (m_pRefineItem && m_pRefineItem->GetExtra() <= 0)
{
m_pRefineItem = nullptr;
FinishUpgrade();
}
if (m_pProtectItem && m_pProtectItem->GetExtra() <= 0)
{
m_pProtectItem = nullptr;
FinishUpgrade();
}
if (m_pChanceItem && m_pChanceItem->GetExtra() <= 0)
{
m_pChanceItem = nullptr;
}
auto pRefineItemProp = m_pRefineItem->GetProp();

if ( pRefineItemProp == nullptr)
FinishUpgrade();

if (m_pTargetItem->IsAccessory() && pRefineItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
{
if (g_pPlayer->GetGold() < 100000)
FinishUpgrade();
}

if (m_dwEnchantTimeEnd < g_tmCurrent)
{
m_bResultSwitch = false;
m_dwEnchantTimeStart = 0xffffffff;
m_dwEnchantTimeEnd = 0xffffffff;

m_pRefineItem->SetExtra(m_pRefineItem->GetExtra() - 1);
m_pProtectItem->SetExtra(m_pProtectItem->GetExtra() - 1);
if (m_pChanceItem != nullptr)
m_pChanceItem->SetExtra(m_pChanceItem->GetExtra() - 1);

g_DPlay.SendSmeltSafety(
m_pTargetItem->m_dwObjId,
m_pRefineItem->m_dwObjId,
m_pProtectItem->m_dwObjId,
m_pChanceItem != nullptr ? m_pChanceItem->m_dwObjId : NULL_ID);
m_dwEnchantTimeStart = g_tmCurrent;
m_dwEnchantTimeEnd = g_tmCurrent + UPGRADE_SPEED;
}
return TRUE;
}

uint8_t CWndFastUpgrade::GetMaxWanted()
{
if (m_pTargetItem == nullptr || m_pRefineItem == nullptr)
return 0;

auto pTargetItemProp = m_pTargetItem->GetProp();
auto pRefineItemProp = m_pRefineItem->GetProp();

if (pTargetItemProp == nullptr || pRefineItemProp == nullptr)
return 0;

if (pRefineItemProp->dwItemKind3 == IK3_ELECARD)
return 20;

if (pRefineItemProp->dwItemKind3 == IK3_SMELT_GENERAL_MATERIAL || pRefineItemProp->dwItemKind3 == IK3_SMELT_ULTIMATE_MATERIAL)
return 10;

if (m_pTargetItem->IsAccessory() && pRefineItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
return MAX_AAO;

if (m_pTargetItem->IsAccessory() == false && pRefineItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
return pTargetItemProp->dwItemKind3 == IK3_SUIT ? MAX_PIERCING_SUIT : MAX_PIERCING;

return 0;
}

uint8_t CWndFastUpgrade::GetTargetItemUpgrade()
{
if (m_pTargetItem == nullptr || m_pRefineItem == nullptr)
return 0;

auto pTargetItemProp = m_pTargetItem->GetProp();
auto pRefineItemProp = m_pRefineItem->GetProp();

if (pTargetItemProp == nullptr || pRefineItemProp == nullptr)
return 0;

if (pRefineItemProp->dwItemKind3 == IK3_ELECARD)
return m_pTargetItem->GetResistAbilityOption();

if (pRefineItemProp->dwItemKind3 == IK3_SMELT_GENERAL_MATERIAL || pRefineItemProp->dwItemKind3 == IK3_SMELT_ULTIMATE_MATERIAL)
return m_pTargetItem->GetAbilityOption();

if (m_pTargetItem->IsAccessory() && pRefineItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
return m_pTargetItem->GetAbilityOption();

if (m_pTargetItem->IsAccessory() == false && pRefineItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
return m_pTargetItem->GetPiercingSize();

return 0;
}

uint8_t CWndFastUpgrade::GetMinWanted()
{
return GetTargetItemUpgrade();
}

void CWndFastUpgrade:oIncreaseWanted()
{
if (m_nWantedUpgrade >= GetMaxWanted())
return;

m_nWantedUpgrade++;
m_szWantedUpgrades.Format("%d", m_nWantedUpgrade);
}
void CWndFastUpgrade:oDecreaseWanted()
{
if (m_nWantedUpgrade <= GetMinWanted())
return;

m_nWantedUpgrade--;

m_szWantedUpgrades.Format("%d", m_nWantedUpgrade);
}

BOOL CWndFastUpgrade::OnChildNotify(UINT message, UINT nID, LRESULT* pLResult)
{
if (nID == WIDC_BUTTON)
DoIncreaseWanted();
if (nID == WIDC_BUTTON1)
DoDecreaseWanted();

if (nID == WIDC_BUTTON2)
{
if (m_pTargetItem == nullptr || m_pRefineItem == nullptr || m_pProtectItem == nullptr)
return FALSE;
m_bResultSwitch = true;
m_bIsUpgrading = true;
m_dwEnchantTimeStart = g_tmCurrent;
m_dwEnchantTimeEnd = g_tmCurrent + UPGRADE_SPEED;
m_mapTries.clear();
}
if (nID == WIDC_BUTTON3)
{
m_bIsUpgrading = false;
}

return CWndNeuz::OnChildNotify(message, nID, pLResult);
}

void CWndFastUpgrade::OnInitialUpdate()
{
CWndNeuz::OnInitialUpdate();


m_lpTargetItem = GetWndCtrl(WIDC_STATIC1);
m_lpRefineItem = GetWndCtrl(WIDC_STATIC3);
m_lpProtectItem = GetWndCtrl(WIDC_STATIC5);
m_lpChanceItem = GetWndCtrl(WIDC_STATIC13);
m_lpTriesBG = GetWndCtrl(WIDC_STATIC10);

CRect rect = m_lpTriesBG->rect;
rect.top += 25;
rect.bottom += 10;
rect.right += 15;

m_wndScrollBar.AddWndStyle(WBS_DOCKING);
m_wndScrollBar.Create(WBS_VERT, rect, this, 1000);

m_pTexMoonStone = CWndBase::m_textureMng.AddTexture(g_Neuz.m_pd3dDev ice, MakePath(DIR_ITEM, "Itm_GenMatMoonstone.dds"), 0xffff00ff);
m_pTexAProtect = CWndBase::m_textureMng.AddTexture(g_Neuz.m_pd3dDev ice, MakePath(DIR_ITEM, "Itm_SysSysScrSmelprot4.dds"), 0xffff00ff);

m_pTexSProtect = CWndBase::m_textureMng.AddTexture(g_Neuz.m_pd3dDev ice, MakePath(DIR_ITEM, "Itm_SysSysScrSmePro.dds"), 0xffff00ff);
m_pTexGProtect = CWndBase::m_textureMng.AddTexture(g_Neuz.m_pd3dDev ice, MakePath(DIR_ITEM, "Itm_SysSysScrPiePro.dds"), 0xffff00ff);
m_pTexUSProtect = CWndBase::m_textureMng.AddTexture(g_Neuz.m_pd3dDev ice, MakePath(DIR_ITEM, "Itm_SysSysScrSmelprot3.dds"), 0xffff00ff);
m_pNowGaugeTexture = CWndBase::m_textureMng.AddTexture(g_Neuz.m_pd3dDev ice, MakePath(DIR_THEME, "SafetyGauge.bmp"), 0xffff00ff);

m_pWndWantedUpgrade = (CWndStatic*)GetDlgItem(WIDC_STATIC8);
m_pWndCost = (CWndStatic*)GetDlgItem(WIDC_STATIC9);

ResetWantedUpgrade();

MoveParentCenter();
}
BOOL CWndFastUpgrade::Initialize(CWndBase* pWndParent, DWORD dwWndId)
{
return CWndNeuz::InitDialog(g_Neuz.GetSafeHwnd(), APP_FASTUPGRADE, 0, CPoint(0, 0), pWndParent);
}

CTexture* CWndFastUpgrade::GetGhostTexture()
{
if (m_pTargetItem == nullptr)
return nullptr;

if (m_pTargetItem->IsAccessory())
return m_pTexAProtect;
else
{
if (m_pRefineItem == nullptr)
return nullptr;

auto pItemProp = m_pRefineItem->GetProp();
if (pItemProp == nullptr)
return nullptr;

if (pItemProp->dwItemKind3 == IK3_SMELT_GENERAL_MATERIAL)
return m_pTexSProtect;

if (pItemProp->dwItemKind3 == IK3_SMELT_ULTIMATE_MATERIAL)
return m_pTexUSProtect;

if (pItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
return m_pTexGProtect;

if (pItemProp->dwItemKind3 == IK3_ELECARD)
return m_pTexSProtect;
}
return nullptr;
}
void CWndFastUpgrade::OnDraw(C2DRender* p2DRender)
{
if (m_pTargetItem != nullptr && m_pTargetItem->GetTexture())
{
m_pTargetItem->GetTexture()->Render(p2DRender, m_lpTargetItem->rect.TopLeft());

if (m_pRefineItem != nullptr && m_pRefineItem->GetTexture())
{
m_pRefineItem->GetTexture()->Render(p2DRender, m_lpRefineItem->rect.TopLeft());
if (m_pRefineItem->GetExtra() > 1)
{
TCHAR szTemp[32];
_stprintf(szTemp, "%d", m_pRefineItem->GetExtra());

CSize size = m_p2DRender->m_pFont->GetTextExtent(szTemp);

m_p2DRender->TextOut(m_lpRefineItem->rect.left + 32 - size.cx, m_lpRefineItem->rect.top + 32 - size.cy, szTemp, 0xff0000ff);
m_p2DRender->TextOut(m_lpRefineItem->rect.left + 31 - size.cx, m_lpRefineItem->rect.top + 31 - size.cy, szTemp, 0xffb0b0f0);
}
}
else
{
if( m_pTargetItem->IsAccessory() && m_pTexMoonStone )
m_pTexMoonStone->Render(p2DRender, m_lpRefineItem->rect.TopLeft(), 80);
}

if (m_pProtectItem != nullptr && m_pProtectItem->GetTexture())
{
m_pProtectItem->GetTexture()->Render(p2DRender, m_lpProtectItem->rect.TopLeft());
if (m_pProtectItem->GetExtra() > 1)
{
TCHAR szTemp[32];
_stprintf(szTemp, "%d", m_pProtectItem->GetExtra());

CSize size = m_p2DRender->m_pFont->GetTextExtent(szTemp);

m_p2DRender->TextOut(m_lpProtectItem->rect.left + 32 - size.cx, m_lpProtectItem->rect.top + 32 - size.cy, szTemp, 0xff0000ff);
m_p2DRender->TextOut(m_lpProtectItem->rect.left + 31 - size.cx, m_lpProtectItem->rect.top + 31 - size.cy, szTemp, 0xffb0b0f0);
}
}
else
{
if (GetGhostTexture())
GetGhostTexture()->Render(p2DRender, m_lpProtectItem->rect.TopLeft(), 80);
}

if (m_pChanceItem != nullptr && m_pChanceItem->GetTexture())
{
m_pChanceItem->GetTexture()->Render(p2DRender, m_lpChanceItem->rect.TopLeft());
if (m_pChanceItem->GetExtra() > 1)
{
TCHAR szTemp[32];
_stprintf(szTemp, "%d", m_pChanceItem->GetExtra());

CSize size = m_p2DRender->m_pFont->GetTextExtent(szTemp);

m_p2DRender->TextOut(m_lpChanceItem->rect.left + 32 - size.cx, m_lpChanceItem->rect.top + 32 - size.cy, szTemp, 0xff0000ff);
m_p2DRender->TextOut(m_lpChanceItem->rect.left + 31 - size.cx, m_lpChanceItem->rect.top + 31 - size.cy, szTemp, 0xffb0b0f0);
}
}
}

if (m_pWndWantedUpgrade)
{
m_pWndWantedUpgrade->SetTitle(m_szWantedUpgrades);
}

if (m_bIsUpgrading != NULL && m_bResultSwitch != false)
{
LPWNDCTRL lpStatic = GetWndCtrl(WIDC_STATIC11);
static CRect rectStaticTemp;

rectStaticTemp.TopLeft().y = lpStatic->rect.top;
rectStaticTemp.TopLeft().x = lpStatic->rect.left;
rectStaticTemp.BottomRight().y = lpStatic->rect.bottom;
uint32_t nGaugeWidth(lpStatic->rect.left + static_cast<uint32_t>(static_cast<float>(lpStatic->rect.right - lpStatic->rect.left)* m_fGaugeRate));
nGaugeWidth = nGaugeWidth < (unsigned int) lpStatic->rect.right ? nGaugeWidth : lpStatic->rect.right;
rectStaticTemp.BottomRight().x = nGaugeWidth;
assert(m_pVertexBufferGauge != NULL);
m_pTheme->RenderGauge(p2DRender, &rectStaticTemp, 0xffffffff, m_pVertexBufferGauge, m_pNowGaugeTexture);
}

DrawTries(p2DRender);
}

int32_t CWndFastUpgrade::GetSelectIndex(const CPoint& point)
{
int32_t nBase = m_wndScrollBar.GetScrollPos();
int32_t nIndex = (point.y - (m_lpTriesBG->rect.top + 10)) / 40;

if (m_lpTriesBG->rect.PtInRect(point))
{
if (0 <= nIndex && nIndex < MAX_DRAWING_TRIES)
{
int32_t nSelect = nBase + nIndex;
if (0 <= nSelect && nSelect < m_nMax)
return nSelect;
}
}
return -1;
}

BOOL CWndFastUpgrade::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
if (zDelta < 0)
{
if (m_wndScrollBar.GetMaxScrollPos() - m_wndScrollBar.GetScrollPage() > m_wndScrollBar.GetScrollPos())
m_wndScrollBar.SetScrollPos(m_wndScrollBar.GetScro llPos() + 1);
else
m_wndScrollBar.SetScrollPos(m_wndScrollBar.GetMaxS crollPos() - m_wndScrollBar.GetScrollPage());
}
else
{
if (m_wndScrollBar.GetMinScrollPos() < m_wndScrollBar.GetScrollPos())
m_wndScrollBar.SetScrollPos(m_wndScrollBar.GetScro llPos() - 1);
else
m_wndScrollBar.SetScrollPos(m_wndScrollBar.GetMinS crollPos());
}

return TRUE;
}

void CWndFastUpgrade::UpdateInfos()
{
m_nMax = m_mapTries.size();

if (m_nMax > 0)
{
m_wndScrollBar.SetScrollRange(0, m_nMax);
if (m_nMax < MAX_DRAWING_TRIES)
m_wndScrollBar.SetScrollPage(m_nMax);
else
m_wndScrollBar.SetScrollPage(MAX_DRAWING_TRIES);
}
else
{
m_wndScrollBar.SetScrollRange(0, 1);
m_wndScrollBar.SetScrollPage(1);
}
}

void CWndFastUpgrade:rawTries(C2DRender* p2DRender)
{
if (g_pPlayer == NULL)
return;

int32_t sx, sy;

int32_t m_nLineHeight = 20;

sx = m_lpTriesBG->rect.left + 5;
sy = m_lpTriesBG->rect.top + 10;

int32_t nBase = m_wndScrollBar.GetScrollPos();
if (nBase < 0)
nBase = 0;

CRect rc(m_lpTriesBG->rect.left, 5, sx, 7);
rc += CPoint(0, 20);

int32_t nDrawCount = 0;

uint8_t i = 0;
for (auto const& itTries : m_mapTries)
{
if (i < m_wndScrollBar.GetScrollPos())
{
++i;
continue;
}

if (i >= nBase + MAX_DRAWING_TRIES)
continue;

if (i >= m_nMax)
break;

CString szString;
szString.Format("+%d : %d essai(s)", itTries.first, itTries.second);

p2DRender->TextOut(sx, sy, szString, 0xFFFFFFFF);

sy += m_nLineHeight;
i++;
nDrawCount++;
}
}

BOOL CWndFastUpgrade::OnDropIcon(LPSHORTCUT pShortcut, CPoint point)
{
CWndBase* pWndFrame = pShortcut->m_pFromWnd->GetFrameWnd();

if (pWndFrame == nullptr)
return FALSE;

if (pWndFrame->GetWndId() != APP_INVENTORY)
return FALSE;

if (pShortcut->m_dwShortcut == SHORTCUT_ITEM && pShortcut->m_pFromWnd != this && pWndFrame->GetWndId() == APP_INVENTORY)
{
if (pShortcut->m_dwType == ITYPE_ITEM && pShortcut->m_dwData)
{
CItemElem* pItemElem = (CItemElem*)g_pPlayer->GetItemId(pShortcut->m_dwId);
if (pItemElem == nullptr)
return FALSE;

if (pItemElem->m_nItemNum <= 1)
{
if (m_lpTargetItem->rect.PtInRect(point))
SetItem(pItemElem, 0, pItemElem->m_nItemNum);
else if (m_lpRefineItem->rect.PtInRect(point))
SetItem(pItemElem, 1, pItemElem->m_nItemNum);
else if (m_lpProtectItem->rect.PtInRect(point))
SetItem(pItemElem, 2, pItemElem->m_nItemNum);
else if (m_lpChanceItem->rect.PtInRect(point))
SetItem(pItemElem, 3, pItemElem->m_nItemNum);
}
else
{
if (m_lpTargetItem->rect.PtInRect(point) || m_lpRefineItem->rect.PtInRect(point) || m_lpProtectItem->rect.PtInRect(point) || m_lpChanceItem->rect.PtInRect(point))
{
g_WndMng.m_pWndTradeGold = new CWndTradeGold;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_dwData = 0;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_dwId = pItemElem->m_dwObjId;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_dwShortcut = SHORTCUT_ITEM;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_pTexture = pItemElem->GetTexture();
g_WndMng.m_pWndTradeGold->m_dwGold = pItemElem->m_nItemNum;
g_WndMng.m_pWndTradeGold->m_nIdWndTo = APP_FASTUPGRADE;
g_WndMng.m_pWndTradeGold->m_pWndBase = GetWndBase(APP_INVENTORY);

g_WndMng.m_pWndTradeGold->Initialize(NULL, APP_TRADE_GOLD);
g_WndMng.m_pWndTradeGold->MoveParentCenter();
CWndStatic* pStatic = (CWndStatic*)g_WndMng.m_pWndTradeGold->GetDlgItem(WIDC_STATIC);
CWndStatic* pStaticCount = (CWndStatic*)g_WndMng.m_pWndTradeGold->GetDlgItem(WIDC_CONTROL1);
CString strMain = prj.GetText(TID_GAME_MOVECOUNT);//"¸î°³¸¦ À̵¿Ç�½Ã°Ú½À´�±î?";
CString strCount = prj.GetText(TID_GAME_NUMCOUNT);// " °¹¼ö : ";
pStatic->m_strTitle = strMain;
pStaticCount->m_strTitle = strCount;
}
}
}
}

return true;
}

void CWndFastUpgrade::ResetWantedUpgrade()
{
m_nWantedUpgrade = 0;
m_szWantedUpgrades = "0";
}

void CWndFastUpgrade::OnRButtonUp(UINT nFlags, CPoint point)
{
if (m_bIsUpgrading)
return;

if (m_pTargetItem && m_lpTargetItem->rect.PtInRect(point))
{
m_pTargetItem->SetExtra(NULL);
m_pTargetItem = nullptr;
if (m_pRefineItem)
{
m_pRefineItem->SetExtra(NULL);
m_pRefineItem = nullptr;
}
if (m_pProtectItem)
{
m_pProtectItem->SetExtra(NULL);
m_pProtectItem = nullptr;
m_pWndCost->SetTitle("");
}
if (m_pChanceItem)
{
m_pChanceItem->SetExtra(NULL);
m_pChanceItem = nullptr;
}

ResetWantedUpgrade();
}
else if(m_pRefineItem && m_lpRefineItem->rect.PtInRect(point))
{
m_pRefineItem->SetExtra(NULL);
m_pRefineItem = nullptr;
if (m_pProtectItem)
{
m_pProtectItem->SetExtra(NULL);
m_pProtectItem = nullptr;
m_pWndCost->SetTitle("");
}
if (m_pChanceItem)
{
m_pChanceItem->SetExtra(NULL);
m_pChanceItem = nullptr;
}
ResetWantedUpgrade();
}
else if (m_pProtectItem && m_lpProtectItem->rect.PtInRect(point))
{
m_pProtectItem->SetExtra(NULL);
m_pProtectItem = nullptr;
m_pWndCost->SetTitle("");
ResetWantedUpgrade();
}
else if (m_pChanceItem && m_lpChanceItem->rect.PtInRect(point))
{
m_pChanceItem->SetExtra(NULL);
m_pChanceItem = nullptr;
}

CWndNeuz::OnRButtonUp(nFlags, point);
}

bool CWndFastUpgrade::IsValidChanceItem(CItemElem* pItemElem)
{
if (m_pTargetItem == nullptr || m_pRefineItem == nullptr)
return false;

auto pRefineItemProp = m_pRefineItem->GetProp();
if (pRefineItemProp == nullptr)
return false;

auto pItemProp = pItemElem->GetProp();
if (pItemProp == nullptr)
return false;

if (pRefineItemProp->dwItemKind3 == IK3_SMELT_GENERAL_MATERIAL && pItemProp->dwID == II_SYS_SYS_SCR_SMELTING)
return true;

if (pRefineItemProp->dwItemKind3 == IK3_ELECARD && pItemProp->dwID == II_SYS_SYS_SCR_SMELTING2)
return true;

return false;
}

bool CWndFastUpgrade::IsValidTargetItem(CItemElem* pItemElem)
{
auto pItemProp = pItemElem->GetProp();
if (pItemProp == nullptr)
return false;

if (pItemProp->dwItemKind1 != IK1_WEAPON && pItemProp->dwItemKind1 != IK1_ARMOR && pItemElem->IsAccessory() == false )
return false;

if (pItemProp->dwItemKind1 == IK1_ARMOR && pItemProp->dwItemKind2 != IK2_ARMOR && pItemProp->dwItemKind2 != IK2_ARMORETC)
return false;

return true;
}

bool CWndFastUpgrade::IsValidRefineItem(CItemElem* pItemElem)
{
if (m_pTargetItem == nullptr)
return false;

auto pTargetItemProp = m_pTargetItem->GetProp();
if (pTargetItemProp == nullptr)
return false;

auto pItemProp = pItemElem->GetProp();
if (pItemProp == nullptr)
return false;

if (m_pTargetItem->IsAccessory() && pItemProp->dwItemKind3 != IK3_SMELT_ACCESSORY_MATERIAL)
return false;

if ((pTargetItemProp->dwItemKind1 == IK1_WEAPON || pTargetItemProp->dwItemKind1 == IK1_ARMOR ) && pItemProp->dwItemKind3 != IK3_SMELT_ULTIMATE_MATERIAL && pItemProp->dwItemKind3 != IK3_SMELT_ACCESSORY_MATERIAL && pItemProp->dwItemKind3 != IK3_SMELT_GENERAL_MATERIAL && pItemProp->dwItemKind3 != IK3_ELECARD)
return false;

if (pTargetItemProp->IsUltimate() && pItemProp->dwItemKind3 == IK3_SMELT_GENERAL_MATERIAL)
return false;
if (pTargetItemProp->IsUltimate() == false && pItemProp->dwItemKind3 == IK3_SMELT_ULTIMATE_MATERIAL)
return false;

if (pTargetItemProp->dwItemKind1 == IK1_ARMOR && pTargetItemProp->dwItemKind3 != IK3_SUIT && pItemProp->dwItemKind3 == IK3_ELECARD)
return false;

return true;
}

bool CWndFastUpgrade::IsValidProtectItem(CItemElem* pItemElem)
{
if (m_pTargetItem == nullptr || m_pRefineItem == nullptr)
return false;

auto pRefineItemProp = m_pRefineItem->GetProp();
if (pRefineItemProp == nullptr)
return false;

auto pItemProp = pItemElem->GetProp();
if (pItemProp == nullptr)
return false;

if ((pRefineItemProp->dwItemKind3 == IK3_SMELT_GENERAL_MATERIAL || pRefineItemProp->dwItemKind3 == IK3_ELECARD) && pItemProp->dwID != II_SYS_SYS_SCR_SMELPROT)
return false;
if (pRefineItemProp->dwItemKind3 == IK3_SMELT_ULTIMATE_MATERIAL && pItemProp->dwID != II_SYS_SYS_SCR_SMELPROT3)
return false;

if (m_pTargetItem->IsAccessory() == false && pRefineItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL && pItemProp->dwID != II_SYS_SYS_SCR_PIEPROT)
return false;

if (m_pTargetItem->IsAccessory() && pRefineItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL && pItemProp->dwID != II_SYS_SYS_SCR_SMELPROT4)
return false;

return true;
}

void CWndFastUpgrade::OnSetItemReq(uint32_t nObjId, uint16_t nQuantity)
{
if (g_pPlayer == nullptr)
return;

auto pItemElem = g_pPlayer->m_Inventory.GetAtId(nObjId);
if (pItemElem == nullptr)
return;

if (IsValidTargetItem(pItemElem))
SetItem(pItemElem, 0, nQuantity);
if (IsValidRefineItem(pItemElem))
SetItem(pItemElem, 1, nQuantity);
if (IsValidProtectItem(pItemElem))
SetItem(pItemElem, 2, nQuantity);
if (IsValidChanceItem(pItemElem))
SetItem(pItemElem, 3, nQuantity);
}

void CWndFastUpgrade::SetItem(CItemElem* pItemElem, uint8_t nSlot, uint16_t nQuantity)
{
if (nSlot > 0 && m_pTargetItem == nullptr)
return;

if (pItemElem == nullptr)
return;

if (pItemElem->m_nItemNum < nQuantity)
return;

switch (nSlot)
{
case 0:
if (m_pTargetItem != nullptr)
return;

if (IsValidTargetItem(pItemElem) == false)
return;

m_pTargetItem = pItemElem;
break;
case 1:
if (m_pRefineItem != nullptr)
return;

if (IsValidRefineItem(pItemElem) == false)
return;

m_pRefineItem = pItemElem;

if (m_pTargetItem->IsAccessory() == false && m_pRefineItem->GetProp() && m_pRefineItem->GetProp()->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
{
m_pWndCost->SetTitle("Attention : Le piercing coûte toujours 100,000 penyas !!");
}
else
m_pWndCost->SetTitle("");

m_nWantedUpgrade = GetMinWanted();
m_szWantedUpgrades.Format("%d", m_nWantedUpgrade);
break;
case 2:
if (m_pProtectItem != nullptr)
return;

if (IsValidProtectItem(pItemElem) == false)
return;

m_pProtectItem = pItemElem;
break;
case 3:
if (m_pChanceItem != nullptr)
return;

if (IsValidChanceItem(pItemElem) == false)
return;

m_pChanceItem = pItemElem;
break;
default: return; break;
}

pItemElem->SetExtra(nQuantity);
}

void CWndFastUpgrade::OnMouseWndSurface(CPoint point)
{
CPoint point2 = point;
CRect DrawRect;
ClientToScreen(&point2);

if (m_pTargetItem && m_lpTargetItem->rect.PtInRect(point))
{
DrawRect = m_lpTargetItem->rect;
ClientToScreen(&DrawRect);
g_WndMng.PutToolTip_Item(m_pTargetItem, point2, &DrawRect);
}
if (m_pRefineItem && m_lpRefineItem->rect.PtInRect(point))
{
DrawRect = m_lpRefineItem->rect;
ClientToScreen(&DrawRect);
g_WndMng.PutToolTip_Item(m_pRefineItem, point2, &DrawRect);
}
if (m_pProtectItem && m_lpProtectItem->rect.PtInRect(point))
{
DrawRect = m_lpProtectItem->rect;
ClientToScreen(&DrawRect);
g_WndMng.PutToolTip_Item(m_pProtectItem, point2, &DrawRect);
}
if (m_pChanceItem && m_lpChanceItem->rect.PtInRect(point))
{
DrawRect = m_lpChanceItem->rect;
ClientToScreen(&DrawRect);
g_WndMng.PutToolTip_Item(m_pChanceItem, point2, &DrawRect);
}
CWndNeuz::OnMouseWndSurface(point);
}



void CWndFastUpgrade::OnResult(uint8_t nResult)
{
if (m_pTargetItem == nullptr || m_pRefineItem == nullptr)
return;
if (nResult == 2)
{

auto pItemProp = m_pRefineItem->GetProp();
if (pItemProp == nullptr)
return;

if (pItemProp->dwItemKind3 == IK3_SMELT_GENERAL_MATERIAL || pItemProp->dwItemKind3 == IK3_SMELT_ULTIMATE_MATERIAL || m_pTargetItem->IsAccessory() && pItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
m_mapTries[m_pTargetItem->GetAbilityOption()+1]++;
else if (pItemProp->dwItemKind3 == IK3_SMELT_ACCESSORY_MATERIAL)
{

m_mapTries[m_pTargetItem->GetPiercingSize()+1]++;
}
else if (pItemProp->dwItemKind3 == IK3_ELECARD)
m_mapTries[m_pTargetItem->GetResistAbilityOption()+1]++;

UpdateInfos();
SetResultSwitch(true);
}
}


HRESULT CWndFastUpgrade::RestoreDeviceObjects()
{
CWndBase::RestoreDeviceObjects();
if (m_pVertexBufferGauge == NULL)
m_pApp->m_pd3dDevice->CreateVertexBuffer(sizeof(TEXTUREVERTEX2) * 3 * 6,
D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC,
D3DFVF_TEXTUREVERTEX2,
D3DPOOL_DEFAULT,
&m_pVertexBufferGauge,
NULL);
assert(m_pVertexBufferGauge != NULL);
return S_OK;
}
HRESULT CWndFastUpgrade::InvalidateDeviceObjects()
{
CWndBase::InvalidateDeviceObjects();
SAFE_RELEASE(m_pVertexBufferGauge);
return S_OK;
}
HRESULT CWndFastUpgrade:eleteDeviceObjects()
{
CWndBase:eleteDeviceObjects();
SAFE_RELEASE(m_pVertexBufferGauge);
return S_OK;
}


#endif

And in .h file add :

 Spoiler

#pragma once
#ifdef _FAST_UPGRADE_SYSTEM

#define MAX_DRAWING_TRIES 11
#define UPGRADE_SPEED 500
class CWndFastUpgrade : public CWndNeuz
{
CItemElem* m_pTargetItem;
CItemElem* m_pRefineItem;
CItemElem* m_pProtectItem;
CItemElem* m_pChanceItem;

LPWNDCTRL m_lpTargetItem;
LPWNDCTRL m_lpRefineItem;
LPWNDCTRL m_lpProtectItem;
LPWNDCTRL m_lpChanceItem;

LPWNDCTRL m_lpTriesBG;
CWndScrollBar m_wndScrollBar;
int32_t m_nSelect;
int32_t m_nMax;

uint8_t m_nWantedUpgrade;

CTexture* m_pTexMoonStone;
CTexture* m_pTexAProtect;
CTexture* m_pTexSProtect;
CTexture* m_pTexGProtect;
CTexture* m_pTexUSProtect;

CWndStatic* m_pWndWantedUpgrade;
CWndStatic* m_pWndCost;

CString m_szWantedUpgrades;

uint32_t m_dwEnchantTimeStart;
uint32_t m_dwEnchantTimeEnd;

float m_fGaugeRate;

bool m_bResultSwitch;
bool m_bIsUpgrading;

map<uint8_t, uint16_t> m_mapTries;

LPDIRECT3DVERTEXBUFFER9 m_pVertexBufferGauge;

CTexture* m_pNowGaugeTexture;
public:
CWndFastUpgrade();
~CWndFastUpgrade();

void OnDraw(C2DRender* p2DRender) override;
void OnInitialUpdate() override;
BOOL Initialize(CWndBase* pWndParent = NULL, DWORD dwWndId = 0) override;
BOOL OnChildNotify(UINT message, UINT nID, LRESULT* pLResult) override;
BOOL OnDropIcon(LPSHORTCUT pShortcut, CPoint point) override;
void OnMouseWndSurface(CPoint point) override;
void OnRButtonUp(UINT nFlags, CPoint point) override;
BOOL Process() override;
HRESULT RestoreDeviceObjects() override;
HRESULT InvalidateDeviceObjects() override;
HRESULT DeleteDeviceObjects() override;

bool IsValidTargetItem(CItemElem* pItemElem);
bool IsValidRefineItem(CItemElem* pItemElem);
bool IsValidProtectItem(CItemElem* pItemElem);
bool IsValidChanceItem(CItemElem* pItemElem);
void SetItem(CItemElem* pItemElem, uint8_t nSlot, uint16_t nQuantity);
void OnSetItemReq(uint32_t nObjId, uint16_t nQuantity);

void DoIncreaseWanted();
void DoDecreaseWanted();

void ResetWantedUpgrade();

void SetResultSwitch(bool bResultSwitch) {m_bResultSwitch = bResultSwitch;}

void UpdateInfos();
void OnResult(uint8_t nResult);
void FinishUpgrade();
void DrawTries(C2DRender* p2DRender);

BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) override;
int32_t GetSelectIndex(const CPoint& point);

CTexture* GetGhostTexture();

uint8_t GetMaxWanted();
uint8_t GetMinWanted();
uint8_t GetTargetItemUpgrade();
};

#endif

In WndField.cpp
Search :

 Spoiler

BOOL CWndTradeGold::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult )

Add below

 Spoiler

else
if( m_nIdWndTo == APP_POST_SEND )
{
if( m_Shortcut.m_dwData == 0 ) // ¥ì¡¤
{
if( nCost > g_pPlayer->GetGold() )
nCost = g_pPlayer->GetGold();

if( nCost > 0 )
{
// ¨¬¢¬©ø¡Ã*¡¾a A¡Ë¢¯¢® ©øO¢¥A¢¥U.

if( g_WndMng.m_pWndPost )
{
g_WndMng.m_pWndPost->m_PostTabSend.SetCost(nCost);
}
}
else
{
// error message
}
}
else // ¨ú¨¡AIAU
{
CItemBase* pItemBase = NULL;
if( m_Shortcut.m_dwType == ITYPE_ITEM )
{
pItemBase = g_pPlayer->GetItemId( m_Shortcut.m_dwId );
if( pItemBase )
{
if( nCost > ( (CItemElem*)pItemBase )->m_nItemNum )
{
nCost = ( (CItemElem*)pItemBase )->m_nItemNum;
}

pItemBase->SetExtra( nCost );

m_Shortcut.m_dwData -= 100;

if( g_WndMng.m_pWndPost )
{
g_WndMng.m_pWndPost->m_PostTabSend.SetItemId( (BYTE)( m_Shortcut.m_dwId ) );
g_WndMng.m_pWndPost->m_PostTabSend.SetCount(nCost);
}
}
}
else
{
// assert(0);
}
}
}

Add above Destroy(); :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
else if (m_nIdWndTo == APP_FASTUPGRADE)
{
CItemBase* pItemBase = NULL;
pItemBase = g_pPlayer->GetItemId(m_Shortcut.m_dwId);
if (pItemBase)
{
if (m_pWndBase)
{
if (g_WndMng.m_pWndFastUpgrade)
g_WndMng.m_pWndFastUpgrade->OnSetItemReq(m_Shortcut.m_dwId, nCost);
}
}
}
#endif

In WndItemCtrl.cpp
Search :

 Spoiler

void CWndItemCtrl::OnRButtonUp( UINT nFlags, CPoint point )
{
int index = HitTest(point);

Add below :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
if (index != -1)
{
CItemElem* pItem = NULL;
CWndBase* pWndBase = this->GetParentWnd();
int nParent;
if (pWndBase)
{
CWndBase* pWndBaseTemp = pWndBase->GetParentWnd();
if (pWndBaseTemp)
nParent = pWndBaseTemp->GetWndId();
else return;
}

if (nParent == APP_INVENTORY)
{
CWndInventory* pWndBaseA = (CWndInventory*)g_WndMng.GetWndBase(APP_INVENTORY) ;
if (!pWndBaseA)
return;

pItem = GetItem(index);

if (IsUsableItem(pItem) && g_WndMng.m_pWndFastUpgrade)
{
g_WndMng.m_pWndTradeGold = new CWndTradeGold;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_dwData = 0;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_dwId = pItem->m_dwObjId;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_dwShortcut = SHORTCUT_ITEM;
g_WndMng.m_pWndTradeGold->m_Shortcut.m_pTexture = pItem->GetTexture();
g_WndMng.m_pWndTradeGold->m_dwGold = pItem->m_nItemNum;
g_WndMng.m_pWndTradeGold->m_nIdWndTo = APP_FASTUPGRADE;
g_WndMng.m_pWndTradeGold->m_pWndBase = GetWndBase(APP_INVENTORY);

g_WndMng.m_pWndTradeGold->Initialize(NULL, APP_TRADE_GOLD);
g_WndMng.m_pWndTradeGold->MoveParentCenter();
CWndStatic* pStatic = (CWndStatic*)g_WndMng.m_pWndTradeGold->GetDlgItem(WIDC_STATIC);
CWndStatic* pStaticCount = (CWndStatic*)g_WndMng.m_pWndTradeGold->GetDlgItem(WIDC_CONTROL1);
CString strMain = prj.GetText(TID_GAME_MOVECOUNT);//"¸î°³¸¦ À̵¿Ç�½Ã°Ú½À´�±î?";
CString strCount = prj.GetText(TID_GAME_NUMCOUNT);// " °¹¼ö : ";
pStatic->m_strTitle = strMain;
pStaticCount->m_strTitle = strCount;
}
}
}
#endif

In WndManager.cpp
Search :

 Spoiler

#ifdef __TREASUREBOX
m_pWndTreasureBox = NULL;
m_pWndTreasureRecieve = NULL;
#endif // __TREASUREBOX

Add :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
m_pWndFastUpgrade = nullptr;
#endif

Search :

 Spoiler

#ifdef __TREASUREBOX
SAFE_DELETE( m_pWndTreasureBox );
SAFE_DELETE( m_pWndTreasureRecieve );
#endif // __TREASUREBOX

Add :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
SAFE_DELETE(m_pWndFastUpgrade);
#endif

Search :

 Spoiler

#ifdef __TREASUREBOX
if( m_pWndTreasureBox == pWndChild )
{
SAFE_DELETE( m_pWndTreasureBox );
pWndChild = NULL;
}
if( m_pWndTreasureRecieve == pWndChild )
{
SAFE_DELETE( m_pWndTreasureRecieve );
pWndChild = NULL;
}
#endif // __TREASUREBOX

Add :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
else if (m_pWndFastUpgrade == pWndChild)
{
SAFE_DELETE(m_pWndFastUpgrade);
pWndChild = NULL;
}
#endif

In WndManager.h add on top of the file add :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
#include "WndFastUpgrade.h"
#endif

Search :

 Spoiler

// ÀÎÅ�ÆäÀ̽º ÅؽºÃç
CTexturePack m_texture;
CTexturePack m_texCommand;
CTexturePack m_texIcon;
CTexturePack m_texWnd;

Add above :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
CWndFastUpgrade* m_pWndFastUpgrade;
#endif

In WndWorld.cpp
Search :

 Spoiler

#ifdef __COLOSSEUM
#ifndef __CORESERVER
case MMI_COLOSSEUM_COLOENTER01:
{
SAFE_DELETE( g_WndMng.m_pColosseumEnter );
g_WndMng.m_pColosseumEnter = new CWndColosseumEnter;
if( g_WndMng.m_pColosseumEnter )
g_WndMng.m_pColosseumEnter->Initialize();
}
break;
#endif // __CORESERVER
#endif // __COLOSSEUM

Add below :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
case MMI_FASTUPGRADE:
{
if (g_WndMng.m_pWndFastUpgrade)
SAFE_DELETE(g_WndMng.m_pWndFastUpgrade);

g_WndMng.m_pWndFastUpgrade = new CWndFastUpgrade;
g_WndMng.m_pWndFastUpgrade->Initialize();
break;
}
#endif

Search :

 Spoiler

#ifdef __NEW_ITEM_VARUNA
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_EXTRACT_OFFER );
if( pWndBase )
pWndBase->Destroy();
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_OFFER );
if( pWndBase )
pWndBase->Destroy();
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_ENCHANT );
if( pWndBase )
pWndBase->Destroy();
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_SEED );
if( pWndBase )
pWndBase->Destroy();
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_OFFERSEED );
if( pWndBase )
pWndBase->Destroy();
#ifdef __BARUNA_PIERCING
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_PIERCE );
if( pWndBase )
pWndBase->Destroy();
#endif // __BARUNA_PIERCING

#ifdef __BARUNA_WAKEUP
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_WAKEUP );
if( pWndBase )
pWndBase->Destroy();
pWndBase = g_WndMng.GetWndBase( APP_BARUNA_WAKEUP_CANCEL );
if( pWndBase )
pWndBase->Destroy();
#endif // __BARUNA_WAKEUP
#endif // __NEW_ITEM_VARUNA

Add below :

 Spoiler

#ifdef _FAST_UPGRADE_SYSTEM
pWndBase = g_WndMng.GetWndBase(APP_FASTUPGRADE);
if (pWndBase)
pWndBase->Destroy();
#endif

In ResData.h Add

 Spoiler

#define APP_FASTUPGRADE &&&&

ResData.inc

 Spoiler

APP_FASTUPGRADE "WndTile00.tga" "" 1 448 368 0x2410000 26
{
// Title String
""
}
{
// ToolTip
""
}
{
WTYPE_STATIC WIDC_STATIC "" 0 20 40 99 59 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC1 "Back_SlotItem.tga" 0 200 35 231 66 0x22000a 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC2 "" 0 20 80 169 99 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC3 "Back_SlotItem.tga" 0 200 75 231 106 0x22000a 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC4 "" 0 20 120 179 139 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC5 "Back_SlotItem.tga" 0 200 115 231 146 0x22000a 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC6 "" 0 66 192 215 211 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_TEXT WIDC_TEXT "WndEditTile00.tga" 1 108 220 172 243 0x20000 0 0 0 0 255 255 255
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_BUTTON WIDC_BUTTON "ButtMap01.tga" 1 78 220 97 239 0x220010 0 0 0 0 0 0 0
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_BUTTON WIDC_BUTTON1 "ButtMap02.tga" 0 178 220 197 239 0x220010 0 0 0 0 0 0 0
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_BUTTON WIDC_BUTTON2 "ButtNormal00.tga" 1 60 254 134 278 0x220010 0 0 0 0 0 0 0
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_BUTTON WIDC_BUTTON3 "ButtNormal00.tga" 0 144 254 218 278 0x220010 0 0 0 0 0 0 0
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC7 "" 0 251 14 420 33 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC8 "" 0 120 222 159 241 0x220010 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC9 "" 0 22 315 421 334 0x220000 0 0 0 0 255 0 0
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC10 "WndEditTile00.tga" 1 249 40 408 276 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC11 "Window02.tga" 0 245 281 413 313 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC12 "" 0 20 162 179 181 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}
WTYPE_STATIC WIDC_STATIC13 "Back_SlotItem.tga" 0 200 155 231 186 0x220000 0 0 0 0 246 204 77
{
// Title String
""
}
{
// ToolTip
""
}

}