alucard/Leviathan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
Leviathan/Client/Game/game/Interface/Decomposition/SUIDecompositionWnd.cpp
T
alucard 379e9da6c2 first commit
2026-06-01 12:46:52 +02:00

2311 lines
74 KiB
C++
Raw Permalink Blame History

#include "stdafx.h"
#include "SUIDecompositionWnd.h"
#include "SLog.h"
//#include "Util.h"
#include "CommonUtil.h"
#include "SGame.h"
#include "SItemDB.h"
#include "SStringDB.h"
#include "SCreatureDB.h"
#include "SUIDefine.h"
#include "KUIDefine.h"
#include "SGameManager.h"
//#include "SGameMessageUI.h"
#include "SGameInterface.h"
#include "SPetMgr.h"
#include "SInventoryMgr.h"
#include "SUIInventoryWnd.h"
#include "SPlayerInfoMgr.h"
#include "SSummonSlotMgr.h"
#include "SUILazyTooltip.h"
#include "SGameSystem.h"
extern SGameSystem * g_pCurrentGameSystem;
namespace nsDecomposeUI
{
static const WORD MAX_DECOMPOSITION_COUNT( 16 ); // 최대 분해 개수
static const WORD MAX_EACH_COUNT( 100 ); // 아이템별 최대 개수
static const WORD MAX_LINE_OF_PAGE( 8 ); // 한 화면에서 보여줄 아이템의 최대 줄 수
static const string BASE_ICON_CONTROL_NAME( "icon_item00" ); // 기본 아이템 아이콘 컨트롤 이름
static const string BASE_ITEMNAME_CONTROL_NAME( "item_name_text_00" ); // 기본 아이템 이름 컨트롤 이름
static const string BASE_ITEMDESC_CONTROL_NAME( "item_info_text_00" ); // 기본 아이템 이름 컨트롤 이름
static const string BASE_BACKGROUND_CONTROL_NAME( "inframe_line_00" ); // 기본 아이템 배경 컨트롤 이름
static const string BASE_SELECT_CONTROL_NAME( "select_list_red_00" ); // 선택 컨트롤 이름
static const string SCROLLBAR_CONTROL_NAME( "scrollbar_list_01" ); // 스크롤 바 컨트롤 이름
static const string ICONSLOT_CONTROL_NAME( "common_panel_titanium_slot_icon" ); // 아이템 슬롯 컨트롤 이름
static const string DO_EMPTY_CONTROL_NAME( "button_remove_01" ); // 비우기 버튼 컨트롤 이름
static const string DO_DECOMPOSITION_CONTROL_NAME( "all_decompose_01" ); // 전체 분해 버튼 컨트롤 이름
static const string ITEMCOUNT_CONTROL_NAME( "decompose_count_01" ); // 아이템 개수 컨트롤 이름
static const string RUPY_CONTROL_NAME( "text_rupy_num_01" ); // 루피 컨트롤 이름
static const string RUPY_OVER_COLOR_VALUE_CONTROL_NAME( "text_rupy_num_over_01" ); // 보유 루피보다 분해 필요 루피가 많을 시 출력 할 폰트 색상 컨트롤 이름
static const string MAX_ITEMCOUNT_COLOR_VALUE_CONTROL_NAME( "decompose_count_over_01" ); // 최대 분해 개수 만큼 아이템이 등록 ‰瑛?시 출략 할 폰트 색상 컨트롤 이름
static const string DO_DECOMPOSITION_DISABLE_COLOR_VALUE_CONTROL_NAME( "all_decompose_disable_01" );// 전체 분해 버튼 컨트롤 비 활성화 시 출력 할 폰트 색상 컨트롤 이름
static const string SYSTEM_MESSAGE_RESULT_ITEMINFO_ITENNAME_TAG( "#@item_name@#" ); // #@item_name@#
static const string SYSTEM_MESSAGE_RESULT_ITEMINFO_ITENCOUNT_TAG( "#@item_num@#" ); // #@item_num@#
static const string NAME_ITEM_AMOUNT( "static_itemcount00" );
static const WORD INVALID_CONTROL_INDEX( -1 );
};
//-----------------------------------------------------------------------------------------------------------------
// 생성자
//-----------------------------------------------------------------------------------------------------------------
SUIDecompositionWnd::SUIDecompositionWnd( SGameManager * pGameManager, SUIDisplayInfo* pDisplayInfo )
: SUIWnd( pGameManager )
, m_pDisplayInfo( pDisplayInfo )
, m_pScrollBar( NULL )
, m_pRupyControl( NULL )
, m_pDoEmptyControl( NULL )
, m_pItemCountControl( NULL )
, m_pDoDecompositionControl( NULL )
, m_nCurrentScrollPosition( NULL )
, m_wCurrentSelectControlIndex( INVALID_CONTROL_INDEX )
, m_nBackgroundControlHeight( NULL )
, m_nBackgroundControlWidth( NULL )
, m_strRupyBasicColorValue( "" )
, m_strRupyNotEnoughColorValue( "" )
, m_strItemCountBasicColorValue( "" )
, m_strItemCountMaxColorValue( "" )
, m_strDoDecompositionEnableColorValue( "" )
, m_strDoDecompositionDisableColorValue( "" )
, m_strRupyPropertyTag( "" )
, m_strItemNamePropertyTag( "" )
, m_strItemDescPropertyTag( "" )
, m_strItemCountPropertyTag( "" )
, m_strDoDecompositionPropertyTag( "" )
, m_n64WaitForAppendItemUniqueID( NULL )
, m_n64NeedPriceTemporaryStorage( NULL )
, m_n64TotalNeedPrice( NULL )
, m_bIsNotEnoughMoney( true )
, m_bIsSendPacket( false )
, m_bIsOpenFinalCautionMessageBox( false )
, m_ntCountForWaiting( 0 )
{
}
//-----------------------------------------------------------------------------------------------------------------
// 파괴자
//-----------------------------------------------------------------------------------------------------------------
SUIDecompositionWnd::~SUIDecompositionWnd()
{
for( UINT nCount = 0; nCount < m_vecControlInfo.size(); nCount++ )
{
PCONTROL_INFO pControlInfo( m_vecControlInfo[nCount] );
SAFE_DELETE( pControlInfo );
}
m_vecControlInfo.clear();
m_mapUniqueID.clear();
}
//-----------------------------------------------------------------------------------------------------------------
// 윈도우 생성
//-----------------------------------------------------------------------------------------------------------------
SUIWnd* SUIDecompositionWnd::CreateWnd( const char* szFile, KUIWndManager* pWndManager, KPoint kPos, int nWindowID )
{
SUIWnd::CreateWnd( szFile, pWndManager, kPos, nWindowID );
if( false == CreateBaseControlInfo() )
return NULL;
if( false == CreateCopyControlInfo() )
return NULL;
ResetControlInfo();
UpdateAppendedItemCount();
UpdateItemInfo();
UpdateRupy();
UpdateButton();
return this;
}
//-----------------------------------------------------------------------------------------------------------------
// 기본 컨트롤 들의 정보를 생성한다.
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::CreateBaseControlInfo()
{
KUIControlMultiIcon* pBaseIconControl( dynamicCast<KUIControlMultiIcon*>( GetChild( BASE_ICON_CONTROL_NAME.c_str() ) ) );
if( NULL == pBaseIconControl )
return false;
else
pBaseIconControl->SetIconLayer( 8 );
//수량
KUIWnd* pBaseItemAmountControl ( GetChild( NAME_ITEM_AMOUNT.c_str() ) );
if( NULL == pBaseItemAmountControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", NAME_ITEM_AMOUNT.c_str() );
assert( pBaseItemAmountControl );
return false;
}
else
pBaseItemAmountControl->SetShow( false );
KUIWnd* pBaseItemNameControl( GetChild( BASE_ITEMNAME_CONTROL_NAME.c_str() ) );
if( NULL == pBaseItemNameControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", BASE_ITEMNAME_CONTROL_NAME.c_str() );
assert( pBaseItemNameControl );
return false;
}
KUIWnd* pBaseItemDescControl( GetChild( BASE_ITEMDESC_CONTROL_NAME.c_str() ) );
if( NULL == pBaseItemDescControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", BASE_ITEMDESC_CONTROL_NAME.c_str() );
assert( pBaseItemDescControl );
return false;
}
KUIWnd* pBassBackgroundControl( GetChild( BASE_BACKGROUND_CONTROL_NAME.c_str() ) );
if( NULL == pBassBackgroundControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", BASE_BACKGROUND_CONTROL_NAME.c_str() );
assert( pBassBackgroundControl );
return false;
}
KUIWnd* pBaseSelectControl( GetChild( BASE_SELECT_CONTROL_NAME.c_str() ) );
if( NULL == pBaseSelectControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", BASE_SELECT_CONTROL_NAME.c_str() );
assert( pBaseSelectControl );
return false;
}
PCONTROL_INFO pControlInfo( new CONTROL_INFO() );
if( NULL == pControlInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] alloc Failed" );
assert( pControlInfo );
return false;
}
pControlInfo->m_wIndex = 0; // 베이스 컨트롤이니깐 0번 이다.
pControlInfo->m_wLineNumber = 0; // 베이스 컨트롤이니깐 0번 라인에 존재한다. ( 한 라인에 2개 씩 존재 )
pControlInfo->m_strIconControl = BASE_ICON_CONTROL_NAME.c_str();
pControlInfo->m_strItemNameControl = BASE_ITEMNAME_CONTROL_NAME.c_str();
pControlInfo->m_strItemDescControl = BASE_ITEMDESC_CONTROL_NAME.c_str();
pControlInfo->m_strBackgroundControl = BASE_BACKGROUND_CONTROL_NAME.c_str();
pControlInfo->m_strSelectControl = BASE_SELECT_CONTROL_NAME.c_str();
pControlInfo->m_pIconControl = pBaseIconControl;
pControlInfo->m_pItemAmountControl = pBaseItemAmountControl;
pControlInfo->m_pItemNameControl = pBaseItemNameControl;
pControlInfo->m_pItemDescControl = pBaseItemDescControl;
pControlInfo->m_pBackgroundControl = pBassBackgroundControl;
pControlInfo->m_pSelectControl = pBaseSelectControl;
m_vecControlInfo.push_back( pControlInfo );
KRect rtBackground( pBassBackgroundControl->GetRect() );
m_nBackgroundControlHeight = rtBackground.GetHeight();
m_nBackgroundControlWidth = rtBackground.GetWidth();
GetTextDecoration( pBaseItemNameControl->GetCaption(), m_strItemNamePropertyTag );
GetTextDecoration( pBaseItemDescControl->GetCaption(), m_strItemDescPropertyTag );
pControlInfo->m_pItemNameControl->SetCaption( m_strItemNamePropertyTag.c_str() );
pControlInfo->m_pItemDescControl->SetCaption( m_strItemDescPropertyTag.c_str() );
return true;
}
//-----------------------------------------------------------------------------------------------------------------
// 최대 분해 아이템 개수만큼 기본 컨트롤로 부터 복사 컨트롤 들의 정보를 생성한다.
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::CreateCopyControlInfo()
{
RECT rtLeftSide;
::ZeroMemory( &rtLeftSide, sizeof( rtLeftSide ) );
RECT rtRightSide;
::ZeroMemory( &rtRightSide, sizeof( rtRightSide ) );
KUIWnd* pBassBackgroundControl( GetChild( BASE_BACKGROUND_CONTROL_NAME.c_str() ) );
if( NULL == pBassBackgroundControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", BASE_BACKGROUND_CONTROL_NAME.c_str() );
assert( pBassBackgroundControl );
return false;
}
else
{
rtLeftSide.top = m_nBackgroundControlHeight;
rtLeftSide.left = -( m_nBackgroundControlWidth );
rtLeftSide.bottom = m_nBackgroundControlHeight;
rtLeftSide.right = -( m_nBackgroundControlWidth );
rtRightSide.left = m_nBackgroundControlWidth;
rtRightSide.right = m_nBackgroundControlWidth;
}
// 컨트롤의 UI에서의 줄 번호 ( 첫 번째 줄은 0번 )
WORD wLineNumber = 0;
// 0번 왼쪽 컨트롤에 대한 정보는 이미 CreateBaseControlInfo 함수에서 생성 되었음.
for( WORD wCount = 1; wCount < MAX_DECOMPOSITION_COUNT; wCount++ )
{
RECT rtAddPosition;
::ZeroMemory( &rtAddPosition, sizeof( rtAddPosition ) );
if( 0 == (wCount % 2) ) // 왼쪽 컨트롤
{
rtAddPosition = rtLeftSide;
++wLineNumber;
}
else // 오른쪽 컨트롤
{
rtAddPosition = rtRightSide;
}
PCONTROL_INFO pControlInfo( new CONTROL_INFO() );
if( NULL == pControlInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] alloc Failed" );
assert( pControlInfo );
continue;
}
string strBackgroundControl_SrcName( StringFormat( "inframe_line_%02d", (wCount - 1) ).c_str() );
string strBackgroundControl_DestName( StringFormat( "inframe_line_%02d", wCount ).c_str() );
KUIWnd* pCopiedBackgroundControl( CopyControl( strBackgroundControl_SrcName.c_str(), strBackgroundControl_DestName.c_str(), rtAddPosition ) );
if( NULL == pCopiedBackgroundControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Background Control Copy Failded" );
assert( pCopiedBackgroundControl );
}
string strSelectControl_SrcName( StringFormat( "select_list_red_%02d", (wCount - 1) ).c_str() );
string strSelectControl_DestName( StringFormat( "select_list_red_%02d", wCount ).c_str() );
KUIWnd* pCopiedSelectControl( CopyControl( strSelectControl_SrcName.c_str(), strSelectControl_DestName.c_str(), rtAddPosition ) );
if( NULL == pCopiedSelectControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Select Control Copy Failded" );
assert( pCopiedSelectControl );
}
string strIconControl_SrcName( StringFormat( "icon_item%02d", (wCount - 1) ).c_str() );
string strIconControl_DestName( StringFormat( "icon_item%02d", wCount ).c_str() );
KUIControlMultiIcon* pCopiedIconControl( dynamicCast<KUIControlMultiIcon*>( CopyControl( strIconControl_SrcName.c_str(), strIconControl_DestName.c_str(), rtAddPosition ) ) );
if( NULL == pCopiedIconControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Icon Control Copy Failded" );
assert( pCopiedIconControl );
}
else
pCopiedIconControl->SetIconLayer( 8 );
string strItemNameControl_SrcName( StringFormat( "item_name_text_%02d", (wCount - 1) ).c_str() );
string strItemNameControl_DestName( StringFormat( "item_name_text_%02d", wCount ).c_str() );
KUIWnd* pCopiedItemNameControl( CopyControl( strItemNameControl_SrcName.c_str(), strItemNameControl_DestName.c_str(), rtAddPosition ) );
if( NULL == pCopiedItemNameControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Item Name Control Copy Failded" );
assert( pCopiedItemNameControl );
}
string strItemDescControl_SrcName( StringFormat( "item_info_text_%02d", (wCount - 1) ).c_str() );
string strItemDescControl_DestName( StringFormat( "item_info_text_%02d", wCount ).c_str() );
KUIWnd* pCopiedItemDescControl( CopyControl( strItemDescControl_SrcName.c_str(), strItemDescControl_DestName.c_str(), rtAddPosition ) );
if( NULL == pCopiedItemDescControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Item Desc Control Copy Failded" );
assert( pCopiedItemDescControl );
}
string strItemCountControl_SrcName( StringFormat( "static_itemcount%02d", (wCount-1) ).c_str() );
string strItemCountControl_DestName( StringFormat( "static_itemcount%02d", wCount ).c_str() );
KUIWnd* pCopiedItemCountCotrol( CopyControl( strItemCountControl_SrcName.c_str(), strItemCountControl_DestName.c_str(), rtAddPosition ) );
if( NULL == pCopiedItemCountCotrol )
{
SDEBUGLOG( "[SUIDecompositionWnd] Item Desc Control Copy Failded" );
assert( pCopiedItemCountCotrol );
}
pControlInfo->m_wIndex = wCount;
pControlInfo->m_wLineNumber = wLineNumber;
pControlInfo->m_strIconControl = strIconControl_DestName.c_str();
pControlInfo->m_strItemNameControl = strItemNameControl_DestName.c_str();
pControlInfo->m_strItemDescControl = strItemDescControl_DestName.c_str();
pControlInfo->m_strBackgroundControl = strBackgroundControl_DestName.c_str();
pControlInfo->m_strSelectControl = strSelectControl_DestName.c_str();
pControlInfo->m_pIconControl = pCopiedIconControl;
pControlInfo->m_pItemNameControl = pCopiedItemNameControl;
pControlInfo->m_pItemDescControl = pCopiedItemDescControl;
pControlInfo->m_pBackgroundControl = pCopiedBackgroundControl;
pControlInfo->m_pSelectControl = pCopiedSelectControl;
pControlInfo->m_pItemAmountControl = pCopiedItemCountCotrol;
m_vecControlInfo.push_back( pControlInfo );
}
return true;
}
//-----------------------------------------------------------------------------------------------------------------
// 컨트롤 초기화
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::InitControls( KPoint kPos )
{
KUIWnd* pTitleBarWnd( GetChild( "titlebar" ) );
if( NULL == pTitleBarWnd )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Title bar UI Control" );
assert( pTitleBarWnd );
}
else
SetCustomMovingRect( pTitleBarWnd->GetRect() );
return SUIWnd::InitControls( kPos );
}
//-----------------------------------------------------------------------------------------------------------------
// 데이터 초기화
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::InitData( bool bReload /*= false*/ )
{
m_pScrollBar = dynamicCast<KUIControlVScrollSmallEx*>( GetChild( SCROLLBAR_CONTROL_NAME.c_str() ) );
if( NULL == m_pScrollBar )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", SCROLLBAR_CONTROL_NAME.c_str() );
assert( m_pScrollBar );
}
else
{
// (두 줄이므로 최대 개수 / 2) - (한 페이지의 보여주는 컨트롤 개수 - 1)
DWORD dwMaxRange ( (MAX_DECOMPOSITION_COUNT * 0.5f) - (MAX_LINE_OF_PAGE - 1) );
m_pScrollBar->SetMaxRange( dwMaxRange );
}
m_pRupyControl = dynamicCast<KUIControlStatic*>( GetChild( RUPY_CONTROL_NAME.c_str() ) );
if( NULL == m_pRupyControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", RUPY_CONTROL_NAME.c_str() );
assert( m_pRupyControl );
}
else
{
string strCaption( m_pRupyControl->GetCaption() );
GetTextDecoration( strCaption.c_str(), m_strRupyPropertyTag );
GetTextColorValue( strCaption, m_strRupyBasicColorValue );
}
/*m_pItemCountControl = dynamicCast<KUIControlStatic*>( GetChild( ITEMCOUNT_CONTROL_NAME.c_str() ) );
if( NULL == m_pItemCountControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", ITEMCOUNT_CONTROL_NAME.c_str() );
assert( m_pItemCountControl );
}
else
{
string strCaption( m_pItemCountControl->GetCaption() );
GetTextDecoration( strCaption.c_str(), m_strItemCountPropertyTag );
GetTextColorValue( strCaption, m_strItemCountBasicColorValue );
}*/
m_pDoEmptyControl = dynamicCast<KUIControlButton*>( GetChild( DO_EMPTY_CONTROL_NAME.c_str() ) );
if( NULL == m_pDoEmptyControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", DO_EMPTY_CONTROL_NAME.c_str() );
assert( m_pDoEmptyControl );
}
KUIControlStatic* pDocompositionDisableColorValueControl = dynamicCast<KUIControlStatic*>( GetChild( DO_DECOMPOSITION_DISABLE_COLOR_VALUE_CONTROL_NAME.c_str() ) );
if( NULL == pDocompositionDisableColorValueControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", DO_DECOMPOSITION_DISABLE_COLOR_VALUE_CONTROL_NAME.c_str() );
assert( pDocompositionDisableColorValueControl );
}
else
{
string strCaption( pDocompositionDisableColorValueControl->GetCaption() );
GetTextDecoration( strCaption.c_str(), m_strDoDecompositionPropertyTag );
GetTextColorValue( strCaption, m_strDoDecompositionDisableColorValue );
}
m_pDoDecompositionControl = dynamicCast<KUIControlButton*>( GetChild( DO_DECOMPOSITION_CONTROL_NAME.c_str() ) );
if( NULL == m_pDoDecompositionControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", DO_DECOMPOSITION_CONTROL_NAME.c_str() );
assert( m_pDoDecompositionControl );
}
else
{
string strCaption( m_pDoDecompositionControl->GetCaption() );
GetTextColorValue( strCaption, m_strDoDecompositionEnableColorValue );
m_pDoDecompositionControl->SetEnableColor( StringFormat( "<#%s>", m_strDoDecompositionEnableColorValue.c_str() ).c_str() );
m_pDoDecompositionControl->SetDisableColor( StringFormat( "<#%s>", m_strDoDecompositionDisableColorValue.c_str() ).c_str() );
m_pDoDecompositionControl->Disable();
}
KUIControlStatic* pRupyOverColorValueControl = dynamicCast<KUIControlStatic*>( GetChild( RUPY_OVER_COLOR_VALUE_CONTROL_NAME.c_str() ) );
if( NULL == pRupyOverColorValueControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", RUPY_OVER_COLOR_VALUE_CONTROL_NAME.c_str() );
assert( pRupyOverColorValueControl );
}
else
{
string strCaption( pRupyOverColorValueControl->GetCaption() );
GetTextColorValue( strCaption, m_strRupyNotEnoughColorValue );
}
KUIControlStatic* pMaxItemCountColorValueControl = dynamicCast<KUIControlStatic*>( GetChild( MAX_ITEMCOUNT_COLOR_VALUE_CONTROL_NAME.c_str() ) );
if( NULL == pMaxItemCountColorValueControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get UI Control - Name[%s]", MAX_ITEMCOUNT_COLOR_VALUE_CONTROL_NAME.c_str() );
assert( pMaxItemCountColorValueControl );
}
else
{
string strCaption( pMaxItemCountColorValueControl->GetCaption() );
GetTextColorValue( strCaption, m_strItemCountMaxColorValue );
}
return SUIWnd::InitData(bReload);
}
//-----------------------------------------------------------------------------------------------------------------
// 윈도우 열리고, 닫힐 때
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::OnNotifyUIWindowOpen( bool bOpen, bool bLimitWnd )
{
if( bOpen )
{
if( IsOpenAnotherUIWindow() )
{
if( m_pGameManager )
m_pGameManager->ProcMsgAtStatic( &SIMSG_REQ_OPEN_MSGBOX( SIMSG_REQ_OPEN_MSGBOX::_MSGBOXID::MSGBOX_GENERAL, S(228) /* 지금은 할 수 없습니다.*/, true ) );
SetShow( false );
SUIWnd::OnNotifyUIWindowOpen( false );
return ;
}
}
else
{
ResetControlInfo();
UpdateAppendedItemCount();
UpdateItemInfo();
UpdateRupy();
UpdateButton();
}
SUIWnd::OnNotifyUIWindowOpen( bOpen );
}
//-----------------------------------------------------------------------------------------------------------------
// 메시지 처리
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::PumpUpMessage( LPCSTR lpszControlID, DWORD nMessage, DWORD lparam, DWORD wparam )
{
if( NULL == lpszControlID )
return;
string strControlID( lpszControlID );
switch( nMessage )
{
case KSCROLL_SELECT:
case KSCROLL_CHANGE:
case KSCROLL_REFRESH:
{
if( NULL == strControlID.compare( SCROLLBAR_CONTROL_NAME.c_str() ) )
{
UpdateScrollBar();
UpdateSelectControl();
}
}
break;
case KBUTTON_CLICK:
case KBUTTON_PRESSING:
{
if( NULL == strControlID.compare( "scroll_btn_up" ) || // 스크롤 위로 버튼 클릭
NULL == strControlID.compare( "scroll_btn_down" ) ) // 스크롤 아래로 버튼 클릭
{
UpdateScrollBar();
UpdateSelectControl();
}
if( NULL == strControlID.compare( DO_EMPTY_CONTROL_NAME.c_str() ) ) // 비우기 버튼 클릭
{
ResetControlInfo();
UpdateAppendedItemCount();
UpdateItemInfo();
UpdateRupy();
UpdateButton();
}
if( NULL == strControlID.compare( "button_close" ) ) // 닫기 버튼 클릭
{
m_pGameManager->PostMsgAtDynamic( new SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_DECOMPOSITION, false ) );
}
if( NULL == strControlID.compare( DO_DECOMPOSITION_CONTROL_NAME.c_str() ) ) // 전체 분해 버튼 클릭
{
m_bIsOpenFinalCautionMessageBox = false;
for( ITER_ITEM_UNIQUE_ID_LIST Iter = m_mapUniqueID.begin(); Iter != m_mapUniqueID.end(); Iter++ )
{
const IN_DATA& kData = Iter->second;
if( IsNeedOpenCautionMessageBox( kData._id ) )
m_bIsOpenFinalCautionMessageBox = true;
}
if( m_bIsOpenFinalCautionMessageBox )
{
if( NULL == m_pGameManager )
{
SDEBUGLOG( "[SUIDecompositionWnd] GameManager Pointer is NULL" );
assert( m_pGameManager );
return;
}
SGameInterface* pGameInterface( m_pGameManager->GetGameInterface() );
if( NULL == pGameInterface )
{
SDEBUGLOG( "[SUIDecompositionWnd] GameInterface Pointer is NULL" );
assert( pGameInterface );
return;
}
pGameInterface->OpenMessageBox( SIMSG_REQ_OPEN_MSGBOX::MSGBOX_YESNO, SIMSG_REQ_OPEN_MSGBOX::MSGBOX_DECOMPOSITON_CONFIRM_DO, false, -1, S( 1265 ) );
}
else
{
OpenProgressiveBar();
}
}
}
break;
case KUI_MESSAGE::KGENWND_MOVE:
{
LimitMoveWnd(); // 게임 외부로 나가지 못하게 제한
}
break;
default:
break;
}
SUIWnd::PumpUpMessage( lpszControlID, nMessage, lparam, wparam );
}
//-----------------------------------------------------------------------------------------------------------------
// 프로그레스 바 윈도우 열기
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::OpenProgressiveBar()
{
if( NULL == m_pGameManager )
return;
m_pGameManager->PostMsgAtDynamic( new SIMSG_SYNTHETIC_ITEM( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_MIX_PROGRESS, SIMSG_TOGGLE_UIWINDOW::UIWINDOW_DECOMPOSITION ) );
m_pGameManager->PostMsgAtDynamic( new SIMSG_SHOW_UIWINDOW( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_MIX_PROGRESS, true, true ) );
}
//-----------------------------------------------------------------------------------------------------------------
// 전체 분해 패킷 전송
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::SendDoDecompsitionPacket()
{
if( m_bIsSendPacket )
{
SDEBUGLOG( "[SUIDecompositionWnd] Already Send Packet" );
assert( NULL );
return false;
}
SMSG_DECOMPOSE_DO stMsg;
for( ITER_ITEM_UNIQUE_ID_LIST Iter = m_mapUniqueID.begin(); Iter != m_mapUniqueID.end(); Iter++ )
{
const IN_DATA& kIterData = Iter->second;
ItemInstance::ItemUID n64UniqueID( kIterData._id );
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( n64UniqueID ) );
if( NULL == pInventorySlot )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Slot Info By UniqueID - [ %u ]", n64UniqueID );
assert( pInventorySlot );
continue;
}
//stMsg.m_vecItemHandle.push_back( pInventorySlot->GetHandle() );
SMSG_DECOMPOSE_DO::IN_DATA kData;
kData._handle = pInventorySlot->GetHandle();
kData._count = (unsigned int)kIterData._count.getAmount();
stMsg.m_vecItemData.push_back( kData );
}
if( m_pGameManager )
{
m_pGameManager->ProcMsgAtStatic( &stMsg );
m_bIsSendPacket = true;
}
return true;
}
//-----------------------------------------------------------------------------------------------------------------
// 정적 메시지 처리
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::ProcMsgAtStatic( SGameMessage* pMsg )
{
if( NULL == pMsg )
return;
switch( pMsg->nType )
{
case IMSG_UI_INPUTNUMBER: //gmpbigsun: 수량입력기로부터 입력받음
{
SIMSG_UI_INPUTNUMBER* pInputNumberMsg = (SIMSG_UI_INPUTNUMBER*)pMsg;
if( pInputNumberMsg->m_nValue < 1 )
{
m_n64WaitForAppendItemUniqueID = 0;
m_ntCountForWaiting = count_t( 0 );
break;
}
else if( pInputNumberMsg->m_nValue > MAX_EACH_COUNT )
{
//최대수량
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( m_n64WaitForAppendItemUniqueID ) );
if( NULL == pInventorySlot )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Slot Info By UniqueID - [ %u ]", m_n64WaitForAppendItemUniqueID );
assert( pInventorySlot );
m_n64WaitForAppendItemUniqueID = 0;
m_ntCountForWaiting = count_t( 0 );
return;
}
pInputNumberMsg->m_nValue = ( pInventorySlot->GetItemCount() > MAX_EACH_COUNT ? count_t( MAX_EACH_COUNT ): pInventorySlot->GetItemCount() );
}
if( IsNeedOpenCautionMessageBox( m_n64WaitForAppendItemUniqueID ) )
{
if( NULL == m_pGameManager )
{
SDEBUGLOG( "[SUIDecompositionWnd] GameManager Pointer is NULL" );
assert( m_pGameManager );
return;
}
SGameInterface* pGameInterface( m_pGameManager->GetGameInterface() );
if( NULL == pGameInterface )
{
SDEBUGLOG( "[SUIDecompositionWnd] GameInterface Pointer is NULL" );
assert( pGameInterface );
return;
}
m_ntCountForWaiting = pInputNumberMsg->m_nValue;
pGameInterface->OpenMessageBox( SIMSG_REQ_OPEN_MSGBOX::MSGBOX_YESNO, SIMSG_REQ_OPEN_MSGBOX::MSGBOX_DECOMPOSITON_CONFIRM_APPEND, false, -1, S( 1265 ) );
}
else
{
if( m_mapUniqueID.size() >= MAX_DECOMPOSITION_COUNT )
return;
if( IsExistItemUniqueID( m_n64WaitForAppendItemUniqueID ) )
return;
if( IsPossibleItemAppend( m_n64WaitForAppendItemUniqueID ) )
{
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( m_n64WaitForAppendItemUniqueID ) );
if( NULL == pInventorySlot )
return;
if( pInventorySlot->GetItemCount() >= pInputNumberMsg->m_nValue )
{
WORD wIndex( m_mapUniqueID.size() );
IN_DATA kData;
kData._id = m_n64WaitForAppendItemUniqueID;
kData._count = pInputNumberMsg->m_nValue;
m_mapUniqueID.insert( make_pair<WORD, IN_DATA>( wIndex, kData ) );
AutoScrollBarMoveWhenAppendItem( wIndex );
SetAppendedItemToInventorySlot( m_n64WaitForAppendItemUniqueID, true );
PCONTROL_INFO pFindControlInfo( FindControlInfo( wIndex ) );
if( pFindControlInfo )
pFindControlInfo->m_n64NeedPrice = m_n64NeedPriceTemporaryStorage;
}
}
}
}
break;
case IMSG_UI_SEND_DATA:
{
SIMSG_UI_SEND_DATA* pRMsg( static_cast<SIMSG_UI_SEND_DATA*>( pMsg ) );
if( NULL == pRMsg )
break;
if( NULL == pRMsg->m_strString.compare( "Append_Yes" ) )
{
if( m_mapUniqueID.size() >= MAX_DECOMPOSITION_COUNT )
return;
if( IsExistItemUniqueID( m_n64WaitForAppendItemUniqueID ) )
return;
if( IsPossibleItemAppend( m_n64WaitForAppendItemUniqueID ) )
{
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( m_n64WaitForAppendItemUniqueID ) );
if( NULL == pInventorySlot )
return;
if( pInventorySlot->GetItemCount() >= m_ntCountForWaiting )
{
WORD wIndex( m_mapUniqueID.size() );
IN_DATA kData;
kData._id = m_n64WaitForAppendItemUniqueID;
kData._count = m_ntCountForWaiting;
m_mapUniqueID.insert( make_pair<WORD, IN_DATA>( wIndex, kData ) );
SetAppendedItemToInventorySlot( m_n64WaitForAppendItemUniqueID, true );
m_n64WaitForAppendItemUniqueID = NULL;
m_ntCountForWaiting = count_t(0);
AutoScrollBarMoveWhenAppendItem( wIndex );
PCONTROL_INFO pFindControlInfo( FindControlInfo( wIndex ) );
if( pFindControlInfo )
pFindControlInfo->m_n64NeedPrice = m_n64NeedPriceTemporaryStorage;
}
}
}
if( NULL == pRMsg->m_strString.compare( "Append_No" ) )
{
m_n64WaitForAppendItemUniqueID = NULL;
m_ntCountForWaiting = count_t(0);
}
if( NULL == pRMsg->m_strString.compare( "Do_Decomposition" ) )
{
OpenProgressiveBar();
}
}
break;
case IMSG_DECOMPOSE_RESULT:
{
SMSG_DECOMPOSE_RESULT* pRMsg( static_cast<SMSG_DECOMPOSE_RESULT*>( pMsg ) );
if( NULL == pRMsg )
break;
OutputResultSystemMessage( pRMsg );
m_bIsSendPacket = false;
}
break;
case MSG_RESULT:
{
m_bIsSendPacket = false;
}
break;
case IMSG_SYNTHETIC_ITEM:
{
SendDoDecompsitionPacket();
ResetControlInfo();
}
break;
case IMSG_UI_MOVE:
{
SIMSG_UI_MOVE* pRMsg( static_cast<SIMSG_UI_MOVE*>( pMsg ) );
if( NULL == pRMsg )
break;
MovePos( pRMsg->m_nX, pRMsg->m_nY );
LimitMoveWnd();
}
break;
case IMSG_HOTKEY_EX: //servantes 2010.10.19
{
SIMSG_HOTKEY_EX* pHotKey = dynamicCast<SIMSG_HOTKEY_EX*>(pMsg);
if( pHotKey->wParam == VK_SHIFT )
m_bShiftKey = (pHotKey->bUp == 0); //servantes 2010.10.15
if( pHotKey->wParam == VK_CONTROL ) //servantes 2010.10.15
m_bControlKey = (pHotKey->bUp == 0);
if( pHotKey->wParam == VK_MENU )
{
bool bPreState = m_bAltKey;
m_bAltKey = (pHotKey->bUp == 0);
if( bPreState != m_bAltKey && IsShow() )
{
// 밑에서 UpdateItemInfo(); 호출하네.
}
}
}
break;
}
UpdateAppendedItemCount();
UpdateControlInfo();
UpdateItemInfo();
UpdateRupy();
UpdateButton();
pMsg->bUse = true;
}
//-----------------------------------------------------------------------------------------------------------------
// 분해 결과를 시스템 메시지로 출력한다.
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::OutputResultSystemMessage( SMSG_DECOMPOSE_RESULT* const pRMsg )
{
if( NULL == pRMsg )
{
SDEBUGLOG( "[SUIDecompositionWnd] Result Message Pointer is NULL" );
assert( pRMsg );
return;
}
for( int nCount = 0; nCount < pRMsg->m_vecItemInfo.size(); nCount++ )
{
SMSG_DECOMPOSE_RESULT::DECOMPOSE_INFO& rItemInfo( pRMsg->m_vecItemInfo[nCount] );
string strResultItemInfoMessage( S( 1264 ) );
string strItemName( m_pDisplayInfo->GetItemName( rItemInfo.m_hItem ) );
string strItemCount( StringFormat( "%u", rItemInfo.m_nItemCount ) );
ReplacePhrase( strResultItemInfoMessage, SYSTEM_MESSAGE_RESULT_ITEMINFO_ITENNAME_TAG, strItemName );
ReplacePhrase( strResultItemInfoMessage, SYSTEM_MESSAGE_RESULT_ITEMINFO_ITENCOUNT_TAG, strItemCount );
if( m_pDisplayInfo )
m_pDisplayInfo->AddSystemMessage( strResultItemInfoMessage.c_str(), 99 );
}
}
//-----------------------------------------------------------------------------------------------------------------
// 마우스 메시지 처리 : 선택 컨트롤
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::ProcessMouseMessage_SelectControl( const PCONTROL_INFO pControlInfo )
{
if( NULL == pControlInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] Control Info Pointer is NULL" );
assert( pControlInfo );
return;
}
ITER_ITEM_UNIQUE_ID_LIST Iter( m_mapUniqueID.find( pControlInfo->m_wIndex ) );
if( Iter == m_mapUniqueID.end() )
return;
KUIWnd* pBackgroundControl( pControlInfo->m_pBackgroundControl );
if( pBackgroundControl->IsShow() )
{
if( INVALID_CONTROL_INDEX != m_wCurrentSelectControlIndex )
{
PCONTROL_INFO pPreSelectControlInfo( FindControlInfo( m_wCurrentSelectControlIndex ) );
if( pPreSelectControlInfo )
{
KUIWnd* pPreSelectControl( pPreSelectControlInfo->m_pSelectControl );
if( pPreSelectControl )
pPreSelectControl->SetShow( false );
}
}
KUIWnd* pSelectControl( pControlInfo->m_pSelectControl );
if( pSelectControl )
{
pSelectControl->SetShow( true );
m_wCurrentSelectControlIndex = pControlInfo->m_wIndex;
}
}
}
//-----------------------------------------------------------------------------------------------------------------
// 마우스 메시지 처리 : 아이템 빼기
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::ProcessMouseMessage_RemoveItem( const PCONTROL_INFO pControlInfo )
{
if( NULL == pControlInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] Control Info Pointer is NULL" );
assert( pControlInfo );
return;
}
DeleteItemUniqueID( pControlInfo->m_wIndex );
UpdateAppendedItemCount();
UpdateControlInfo();
UpdateItemInfo();
UpdateRupy();
UpdateButton();
}
//-----------------------------------------------------------------------------------------------------------------
// 마우스 메시지 처리
//-----------------------------------------------------------------------------------------------------------------
DWORD SUIDecompositionWnd::OnMouseMessage(DWORD dwMessage, int x, int y)
{
PCONTROL_INFO pFindControlInfo( FindControlInfo( KPoint( x, y ) ) );
if ( KLBUTTON_DOWN == dwMessage )
ProcessMouseMessage_SelectControl( pFindControlInfo );
if ( KLBUTTON_DBLCLK == dwMessage )
ProcessMouseMessage_RemoveItem( pFindControlInfo );
return SUIWnd::OnMouseMessage(dwMessage, x, y);
}
//-----------------------------------------------------------------------------------------------------------------
// 아이콘 드래그 이벤트 시작 시 처리
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::Process_UIBeginDrag( KUIBeginDragMessage* const pRecvMsg )
{
if( NULL == m_pDisplayInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] DisplayInfo Pointer is NULL" );
assert( m_pDisplayInfo );
return false;
}
if( NULL == m_pDragAndDropIcon )
{
SDEBUGLOG( "[SUIDecompositionWnd] Drag and Drop Icon Pointer is NULL" );
assert( m_pDisplayInfo );
return false;
}
string strControlID( pRecvMsg->sDragControlID );
for( UINT nCount = 0; nCount < m_vecControlInfo.size(); nCount++ )
{
PCONTROL_INFO pControlInfo( m_vecControlInfo[nCount] );
if( NULL == pControlInfo )
continue;
if( NULL == pControlInfo->m_strIconControl.compare( strControlID ) )
{
KUIControlMultiIcon* pIconControl( pControlInfo->m_pIconControl );
if( NULL == pIconControl )
return false;
ITER_ITEM_UNIQUE_ID_LIST Iter( m_mapUniqueID.find( pControlInfo->m_wIndex ) );
if( Iter == m_mapUniqueID.end() )
return false;
m_pDisplayInfo->SetUIDragInfo( new SUIDecompositionDragInfo( pControlInfo->m_wIndex ) );
const KUIControlMultiIcon::ICON_INFO& rIconInfo = pIconControl->GetIconInfoByLayer( 0 );
m_pDragAndDropIcon->SetStateIcon( pIconControl->GetSprName(), rIconInfo.sAniName.c_str(), rIconInfo.nFrameIndex, STATE_NORMAL );
pRecvMsg->pDragAndDropRenderer = m_pDragAndDropIcon;
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------------------------------------------
// 아이콘 드롭 이벤트 메시지 받을 시 처리
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::Process_UIReceiveDrop( const KUISendRecvDropMessage* const pRecvMsg )
{
if( NULL == m_pDisplayInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] DisplayInfo Pointer is NULL" );
assert( m_pDisplayInfo );
return;
}
SUIDragInfo* pUIDragInfo( m_pDisplayInfo->GetUIDragInfo() );
if( NULL == pUIDragInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] DragInfo Pointer is NULL" );
assert( pUIDragInfo );
return;
}
if( pUIDragInfo->m_type == SUIDragInfo::DRAGTYPE_INVENITEM )
{
if( NULL == m_pManager )
return;
KUIWnd* pFindWnd( m_pManager->FindWnd( pRecvMsg->sSendDropParentID.c_str() ) );
if( NULL == pFindWnd )
return;
SUIInventoryWnd* pInventoryWnd( static_cast<SUIInventoryWnd*>( pFindWnd ) );
if( NULL == pInventoryWnd )
return;
int nSlotNumber( pInventoryWnd->GetSlotControlNum( pRecvMsg->sSendDropControlID.c_str() ) );
if( -1 == nSlotNumber )
return;
SInventorySlot* pSlot( pInventoryWnd->GetInvenItem( nSlotNumber ) );
if( NULL == pSlot )
return;
AppendItemUniqueID( pSlot->GetUID() );
}
}
//-----------------------------------------------------------------------------------------------------------------
// 아이콘 드롭 이벤트 메시지 보낼 시 처리
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::Process_UISendDrop( const KUISendRecvDropMessage* const pRecvMsg )
{
if( NULL == m_pDisplayInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] DisplayInfo Pointer is NULL" );
assert( m_pDisplayInfo );
return;
}
SUIDecompositionDragInfo* pUIDragInfo( static_cast<SUIDecompositionDragInfo*>( m_pDisplayInfo->GetUIDragInfo() ) );
if( NULL == pUIDragInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] DragInfo Pointer is NULL" );
assert( pUIDragInfo );
return;
}
if( SUIDragInfo::DRAGTYPE_DECOMPOSITION != pUIDragInfo->m_type )
return;
if( NULL == pRecvMsg->sRecvDropParentID.compare( "window_sub_inventory_decompose" ) )
return;
DeleteItemUniqueID( pUIDragInfo->m_wIndex );
m_pDisplayInfo->SetUIDragInfo();
UpdateAppendedItemCount();
UpdateControlInfo();
UpdateItemInfo();
UpdateRupy();
UpdateButton();
}
//-----------------------------------------------------------------------------------------------------------------
// 윈도우 갱신
//-----------------------------------------------------------------------------------------------------------------
void* SUIDecompositionWnd::Perform( KID id, KArg& msg )
{
_CID( UI_BEGIN_DRAG );
_CID( UI_SEND_DROP );
_CID( UI_RECV_DROP );
if ( id == id_UI_RECV_DROP )
{
KUISendRecvDropMessage* pRecvMsg( static_cast<KUISendRecvDropMessage*>( &msg ) );
if( pRecvMsg )
{
Process_UIReceiveDrop( pRecvMsg );
return NULL;
}
}
if ( id == id_UI_BEGIN_DRAG )
{
KUIBeginDragMessage* pBeginMsg( static_cast<KUIBeginDragMessage*>( &msg ) );
if( pBeginMsg )
{
Process_UIBeginDrag( pBeginMsg );
return NULL;
}
}
if ( id == id_UI_SEND_DROP )
{
KUISendRecvDropMessage* pSendMsg( static_cast<KUISendRecvDropMessage*>( &msg ) );
if( pSendMsg )
{
Process_UISendDrop( pSendMsg );
return NULL;
}
}
return SUIWnd::Perform( id, msg );
}
//-----------------------------------------------------------------------------------------------------------------
// 인덱스로 부터 컨트롤 정보 얻기
//-----------------------------------------------------------------------------------------------------------------
PCONTROL_INFO SUIDecompositionWnd::FindControlInfo( const WORD wIndex )
{
for( UINT nCount = 0; nCount < m_vecControlInfo.size(); nCount++ )
{
PCONTROL_INFO pControlInfo( m_vecControlInfo[nCount] );
if( NULL == pControlInfo )
continue;
if( pControlInfo->m_wIndex == wIndex )
return pControlInfo;
}
return NULL;
}
//-----------------------------------------------------------------------------------------------------------------
// 마우스 좌표로 부터 컨트롤 정보 얻기
// 설명 : 배경 컨트롤 기준으로 컨트롤을 찾는다.
//-----------------------------------------------------------------------------------------------------------------
PCONTROL_INFO SUIDecompositionWnd::FindControlInfo( const KPoint ptMouse )
{
for( UINT nCount = 0; nCount < m_vecControlInfo.size(); nCount++ )
{
PCONTROL_INFO pControlInfo( m_vecControlInfo[nCount] );
if( NULL == pControlInfo )
continue;
KUIWnd* pBackground( pControlInfo->m_pBackgroundControl );
if( NULL == pBackground )
continue;
if( pBackground->GetRect().IsInRect( ptMouse.x, ptMouse.y ) )
return pControlInfo;
}
return NULL;
}
//-----------------------------------------------------------------------------------------------------------------
// 아이템 정보 갱신
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::UpdateItemInfo()
{
if( NULL == m_pDisplayInfo )
return;
for( ITER_ITEM_UNIQUE_ID_LIST Iter = m_mapUniqueID.begin(); Iter != m_mapUniqueID.end(); Iter++ )
{
WORD wIndex( Iter->first );
const IN_DATA& kData = Iter->second;
ItemInstance::ItemUID n64UniqueID( kData._id );
PCONTROL_INFO pControlInfo( FindControlInfo( wIndex ) );
if( NULL == pControlInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Control Info - Index [ %d ]", wIndex );
assert( pControlInfo );
continue;
}
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( n64UniqueID ) );
if( NULL == pInventorySlot )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Slot Info By UniqueID - [ %u ]", n64UniqueID );
assert( pInventorySlot );
continue;
}
KUIWnd* pItemNameControlWnd( pControlInfo->m_pItemNameControl );
if( NULL == pItemNameControlWnd )
{
SDEBUGLOG( "[SUIDecompositionWnd] Item Name Control Pointer is NULL - Index [ %d ]", wIndex );
assert( pItemNameControlWnd );
continue;
}
// 이름 설정
string strItemName( m_strItemNamePropertyTag.c_str() );
strItemName.append( m_pDisplayInfo->GetItemName( pInventorySlot->GetItemCode(), true, pInventorySlot->GetEnhance(), pInventorySlot->GetLevel(), pInventorySlot->GetXFlag(), false, 0, false, pInventorySlot->GetRandomOption() ) );
pItemNameControlWnd->SetCaption( strItemName.c_str() );
KUIControlMultiIcon* pItemIconControl( pControlInfo ->m_pIconControl );
if( NULL == pItemIconControl )
{
SDEBUGLOG( "[SUIDecompositionWnd] Item Icon Control Pointer is NULL - Index [ %d ]", wIndex );
assert( pItemIconControl );
continue;
}
else
{
ResetMultiIcon( pItemIconControl, 0, 8 );
if( false == setSkillCardIcon( pItemIconControl, pInventorySlot->GetItemCode() ) && false == setSummonCardIcon( pItemIconControl, pInventorySlot ) )
{
string strIconName( "" );
getIconNameAtDurability( pInventorySlot, strIconName );
pItemIconControl->SetIcon( 0, c_szDEF_SPR_NAME, strIconName.c_str() );
}
pItemIconControl->SetIcon( 1, c_szDEF_SPR_NAME, pInventorySlot->GetXFlag().IsOn( ItemInstance::ITEM_FLAG_CARD ) ? "static_common_useunitcardicon" : NULL );
EquipItemAddtionalIconSetter icon_setter( pItemIconControl, pInventorySlot );
if( pInventorySlot->GetItemAppearance() )
pItemIconControl->SetIcon( 4, c_szDEF_SPR_NAME, g_strLookChangeIcon );
pItemIconControl->SetLazyTooltip( new rp::KLazyItemTooltip( *m_pDisplayInfo, pInventorySlot, true ) );
if( m_bAltKey )
{
m_pDisplayInfo->SetComparableEquipItemSubTooltip( pItemIconControl, pInventorySlot );
}
// 개수
count_t nCount( kData._count );
bool bRenderCount = false;
// 중복가능하다면 무조건 표기
if( GetItemDB().IsJoin( pInventorySlot->GetItemCode(), IsInstanceUnstackable( pInventorySlot ) ) )
bRenderCount = true;
SetChildShow( CStringUtil::StringFormat( "static_itemcount%02d", wIndex ).c_str(), bRenderCount );
if( bRenderCount )
SetChildCaption( CStringUtil::StringFormat( "static_itemcount%02d", wIndex ).c_str(), CStringUtil::StringFormat( "<hcenter><right><b><size:10>%I64d", nCount.getAmount() ).c_str() );
}
}
}
//-----------------------------------------------------------------------------------------------------------------
// 아이템 등록 시 스크롤 바 자동 이동
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::AutoScrollBarMoveWhenAppendItem( const WORD wIndex )
{
if( NULL == m_pScrollBar )
{
SDEBUGLOG( "[SUIDecompositionWnd] Scroll Bar Pointer is NULL" );
assert( m_pScrollBar );
return;
}
PCONTROL_INFO pControlInfo( FindControlInfo( wIndex ) );
if( NULL == pControlInfo )
{
SDEBUGLOG( "[SUIDecompositionWnd] Control Info Pointer is NULL" );
assert( pControlInfo );
return;
}
WORD wMinScrollPosition( m_nCurrentScrollPosition );
WORD wMaxScrollPosition( m_nCurrentScrollPosition + MAX_LINE_OF_PAGE - 1 );
if( pControlInfo->m_wLineNumber < wMinScrollPosition ||
pControlInfo->m_wLineNumber > wMaxScrollPosition )
{
int nCalcScrollBarPosition( pControlInfo->m_wLineNumber - ( MAX_LINE_OF_PAGE - 1 ) );
if( nCalcScrollBarPosition < 0 )
nCalcScrollBarPosition = 0;
m_pScrollBar->SetPosition( nCalcScrollBarPosition );
UpdateScrollBar();
UpdateSelectControl();
}
}
//-----------------------------------------------------------------------------------------------------------------
// 선택 컨트롤 갱신
// 설명 : 스크를의 값에 따라 선택 컨트롤을 보이고 / 숨긴다.
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::UpdateSelectControl()
{
if( INVALID_CONTROL_INDEX == m_wCurrentSelectControlIndex )
return;
WORD wMinScrollPosition( m_nCurrentScrollPosition );
WORD wMaxScrollPosition( m_nCurrentScrollPosition + MAX_LINE_OF_PAGE - 1 );
PCONTROL_INFO pSelectControlInfo( FindControlInfo( m_wCurrentSelectControlIndex ) );
if( NULL == pSelectControlInfo )
return;
ITER_ITEM_UNIQUE_ID_LIST Iter( m_mapUniqueID.find( pSelectControlInfo->m_wIndex ) );
if( Iter == m_mapUniqueID.end() )
return;
KUIWnd* m_pBackgroundControl( pSelectControlInfo->m_pBackgroundControl );
if( NULL == m_pBackgroundControl )
return;
bool bParentShow( m_pBackgroundControl->IsShow() );
if( pSelectControlInfo->m_pSelectControl )
pSelectControlInfo->m_pSelectControl->SetShow( bParentShow );
}
//-----------------------------------------------------------------------------------------------------------------
// 스크롤 바 갱신
// 설명 : 스크를의 값에 따라 컨트롤 들을 이동 시키며, 보이고 / 숨긴다.
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::UpdateScrollBar()
{
if( NULL == m_pScrollBar )
return ;
int nPreScrollPosition( m_nCurrentScrollPosition );
if( m_pScrollBar->GetPosition() < 0 )
m_nCurrentScrollPosition = 0;
else
m_nCurrentScrollPosition = m_pScrollBar->GetPosition();
int nGapScrollPosition( m_nCurrentScrollPosition - nPreScrollPosition );
WORD wMinScrollPosition( m_nCurrentScrollPosition );
WORD wMaxScrollPosition( m_nCurrentScrollPosition + MAX_LINE_OF_PAGE - 1 );
for( UINT nCount = 0; nCount < m_vecControlInfo.size(); nCount++ )
{
PCONTROL_INFO pControlInfo( m_vecControlInfo[nCount] );
if( NULL == pControlInfo )
{
assert( pControlInfo );
continue;
}
pControlInfo->MovePosOffset( 0, nGapScrollPosition * m_nBackgroundControlHeight );
pControlInfo->SetShow( false );
if( pControlInfo->m_wLineNumber >= wMinScrollPosition &&
pControlInfo->m_wLineNumber <= wMaxScrollPosition )
{
pControlInfo->SetShow( true );
}
}
}
//-----------------------------------------------------------------------------------------------------------------
// 버튼 컨트롤 갱신
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::UpdateButton()
{
if( m_pDoDecompositionControl )
{
if( m_mapUniqueID.size() > 0 )
{
if( m_bIsNotEnoughMoney )
m_pDoDecompositionControl->Disable();
else
m_pDoDecompositionControl->Enable();
}
else
m_pDoDecompositionControl->Disable();
}
}
//-----------------------------------------------------------------------------------------------------------------
// 돈 (루피) 컨트롤 갱신
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::UpdateRupy()
{
if( m_pRupyControl )
{
money_t n64TotalPrice( GetTotalDecompositionPrice() );
money_t n64UserRupy( m_PlayerInfoMgr.GetGold() );
string strTotalPrice( "" );
string strRupyPropertyTag( m_strRupyPropertyTag );
if( n64UserRupy < n64TotalPrice )
{
ReplaceTextColorValue( strRupyPropertyTag, m_strRupyNotEnoughColorValue );
m_bIsNotEnoughMoney = true;
}
else
{
ReplaceTextColorValue( strRupyPropertyTag, m_strRupyBasicColorValue );
m_bIsNotEnoughMoney = false;
}
strTotalPrice.append( strRupyPropertyTag );
strTotalPrice.append( CStringUtil::GetCommaNumberString( n64TotalPrice.getAmount() ) );
m_pRupyControl->SetCaption( strTotalPrice.c_str() );
}
}
//-----------------------------------------------------------------------------------------------------------------
// 컨트롤 정보 갱신
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::UpdateControlInfo()
{
for( UINT nCount = 0; nCount < m_vecControlInfo.size(); nCount++ )
{
PCONTROL_INFO pControlInfo( m_vecControlInfo[nCount] );
if( pControlInfo )
{
ITER_ITEM_UNIQUE_ID_LIST Iter( m_mapUniqueID.find( pControlInfo->m_wIndex ) );
if( Iter != m_mapUniqueID.end() )
continue;
if( pControlInfo->m_pIconControl )
{
ResetMultiIcon( pControlInfo->m_pIconControl, 0, 8 );
pControlInfo->m_pIconControl->SetIcon( NULL, c_szDEF_SPR_NAME, ICONSLOT_CONTROL_NAME.c_str() );
pControlInfo->m_pIconControl->SetTooltip();
}
if( pControlInfo->m_pItemNameControl )
pControlInfo->m_pItemNameControl->SetCaption( m_strItemNamePropertyTag.c_str() );
if( pControlInfo->m_pItemDescControl )
pControlInfo->m_pItemDescControl->SetCaption( m_strItemDescPropertyTag.c_str() );
if( pControlInfo->m_pSelectControl )
pControlInfo->m_pSelectControl->SetShow( false );
if( pControlInfo->m_pItemAmountControl )
pControlInfo->m_pItemAmountControl->SetShow( false );
pControlInfo->m_n64NeedPrice = money_t( NULL );
}
}
}
//-----------------------------------------------------------------------------------------------------------------
// 등록 된 아이템 개수 갱신
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::UpdateAppendedItemCount()
{
/*if( m_pItemCountControl )
{
UINT nItemCount( m_mapUniqueID.size() );
string strItemCount( "" );
string strItemCountPropertyTag( m_strItemCountPropertyTag );
if( nItemCount >= MAX_DECOMPOSITION_COUNT )
{
ReplaceTextColorValue( strItemCountPropertyTag, m_strItemCountMaxColorValue );
strItemCount.append( strItemCountPropertyTag );
strItemCount.append( StringFormat( "%d", m_mapUniqueID.size() ) );
strItemCount.append( StringFormat( "<#%s> / %d", m_strItemCountBasicColorValue.c_str(), MAX_DECOMPOSITION_COUNT ) );
}
else
{
ReplaceTextColorValue( strItemCountPropertyTag, m_strItemCountBasicColorValue );
strItemCount.append( strItemCountPropertyTag );
strItemCount.append( StringFormat( "%d / %d", m_mapUniqueID.size(), MAX_DECOMPOSITION_COUNT ) );
}
m_pItemCountControl->SetCaption( strItemCount.c_str() );
}*/
}
//-----------------------------------------------------------------------------------------------------------------
// 분해하는데 드는 총 소모비용 얻기
//-----------------------------------------------------------------------------------------------------------------
money_t SUIDecompositionWnd::GetTotalDecompositionPrice()
{
money_t n64TotalPrice( NULL );
for( ITER_ITEM_UNIQUE_ID_LIST Iter = m_mapUniqueID.begin(); Iter != m_mapUniqueID.end(); Iter++ )
{
WORD wIndex( Iter->first );
const IN_DATA& kData = Iter->second;
ItemInstance::ItemUID n64UniqueID( kData._id );
PCONTROL_INFO pControlInfo( FindControlInfo( wIndex ) );
if( pControlInfo )
n64TotalPrice += pControlInfo->m_n64NeedPrice * kData._count;
}
return n64TotalPrice;
}
//-----------------------------------------------------------------------------------------------------------------
// 컨트롤 정보 초기화
// 설명 : 생성 된 컨트롤의 위치, 아이콘, 아이템 이름, 스크롤 위치를 초기화 한다.
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::ResetControlInfo()
{
for( UINT nCount = 0; nCount < m_vecControlInfo.size(); nCount++ )
{
PCONTROL_INFO pControlInfo( m_vecControlInfo[nCount] );
if( pControlInfo )
{
// 소모 비용 초기화
pControlInfo->m_n64NeedPrice = money_t( NULL );
// 컨트롤 위치 초기화
pControlInfo->ReturnToOriginPos();
// 아이템 아이콘 초기화
if( pControlInfo->m_pIconControl )
{
ResetMultiIcon( pControlInfo->m_pIconControl, 0, 8 );
pControlInfo->m_pIconControl->SetIcon( NULL, c_szDEF_SPR_NAME, ICONSLOT_CONTROL_NAME.c_str() );
pControlInfo->m_pIconControl->SetTooltip();
}
// 아이템 이름 초기화
if( pControlInfo->m_pItemNameControl )
pControlInfo->m_pItemNameControl->SetCaption( m_strItemNamePropertyTag.c_str() );
// 아이템 설명 초기화
if( pControlInfo->m_pItemDescControl )
pControlInfo->m_pItemDescControl->SetCaption( m_strItemDescPropertyTag.c_str() );
if( pControlInfo->m_pSelectControl )
pControlInfo->m_pSelectControl->SetShow( false );
//아이템 갯수 초기화
if( pControlInfo->m_pItemAmountControl )
pControlInfo->m_pItemAmountControl->SetShow( false );
}
}
m_wCurrentSelectControlIndex = INVALID_CONTROL_INDEX;
// 스크롤 바 초기화
if( m_pScrollBar )
{
m_pScrollBar->SetPosition( NULL );
m_nCurrentScrollPosition = 0;
UpdateScrollBar();
}
// 분해 될 아이템 정보 초기화
for( ITER_ITEM_UNIQUE_ID_LIST Iter = m_mapUniqueID.begin(); Iter != m_mapUniqueID.end(); Iter++ )
{
const IN_DATA& kData = Iter->second;
SetAppendedItemToInventorySlot( kData._id, false );
}
m_mapUniqueID.clear();
}
//-----------------------------------------------------------------------------------------------------------------
// DB로 부터 유효한 조합식을 찾았는가 ? ( 이건 서버와 같은 로직을 쓴다 변경 시 서버와 상의 할 것 )
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::IsFindValidDecomositionFormula( const SInventorySlot* const pSlot, const ItemBaseEx_info* const pItemBase, DECOMPOSE_FORMULA_INFO* const pFormulaInfo )
{
vector<DECOMPOSE_IDENTITY_INFO>& vecIdentity( pFormulaInfo->m_vecIdentity );
for( UINT nCount = 0; nCount < vecIdentity.size(); nCount++ )
{
int nValue( vecIdentity[nCount].m_nValue );
switch( vecIdentity[nCount].m_nType )
{
case eCHECK_ITEM_GROUP:
{
if( pItemBase->nGroup != nValue )
return false;
}
break;
case eCHECK_ITEM_GROUP_NE:
{
if( pItemBase->nGroup == nValue )
return false;
}
break;
case eCHECK_ITEM_CLASS:
{
if( pItemBase->nClass != nValue )
return false;
}
break;
case eCHECK_ITEM_ID:
{
if( pSlot->GetItemCode() != nValue )
return false;
}
break;
case eCHECK_ITEM_RANK:
{
if( pItemBase->nRank != nValue )
return false;
}
break;
case eCHECK_ITEM_LEVEL:
{
if( pSlot->GetLevel() != nValue )
return false;
}
break;
case eCHECK_FLAG_ON:
{
if( false == pSlot->GetXFlag().IsOn( nValue ) )
return false;
}
break;
case eCHECK_FLAG_OFF:
{
if( pSlot->GetXFlag().IsOn( nValue ) )
return false;
}
break;
case eCHECK_ENHANCE_MATCH:
{
if( pSlot->GetEnhance() != nValue )
return false;
}
break;
case eCHECK_ENHANCE_DISMATCH:
{
if( pSlot->GetEnhance() == nValue )
return false;
}
break;
case eCHECK_ITEM_COUNT:
{
if( pSlot->GetItemCount() != nValue )
return false;
}
break;
case eCHECK_ITEM_COUNT_GE:
{
if( pSlot->GetItemCount() < nValue )
return false;
}
break;
case eCHECK_ITEM_ETHEREAL_DURABILITY_E:
{
if( pSlot->GetEtherealDurability() != nValue )
return false;
}
break;
case eCHECK_ITEM_ETHEREAL_DURABILITY_NE:
{
if( pSlot->GetEtherealDurability() == nValue )
return false;
}
break;
case eCHECK_ELEMENTAL_EFFECT_MATCH:
{
int nItemElementalEffectBitflag = static_cast< int >( pow( 2.0, pSlot->GetEET() ) ) >> 1;
if( !nItemElementalEffectBitflag )
{
if( nValue )
return false;
}
else if( ( nItemElementalEffectBitflag & nValue ) != nItemElementalEffectBitflag )
return false;
else
__noop;
}
break;
case eCHECK_ELEMENTAL_EFFECT_MISMATCH:
{
int nItemElementalEffectBitflag = static_cast< int >( pow( 2.0, pSlot->GetEET() ) ) >> 1;
if( !nItemElementalEffectBitflag )
{
if( !nValue )
return false;
}
else if( ( nItemElementalEffectBitflag & nValue ) == nItemElementalEffectBitflag )
return false;
else
__noop;
}
break;
case eCHECK_ITEM_WEAR_POSITION_MATCH:
{
if( pItemBase->WearType != nValue )
return false;
}
break;
case eCHECK_ITEM_WEAR_POSITION_MISMATCH:
{
if( pItemBase->WearType == nValue )
return false;
}
break;
case eCHECK_ITEM_GRADE:
{
if( pItemBase->nGrade != nValue )
return false;
}
break;
case eCHECK_ITEM_EXPIRED_TIME_GE:
{
bool bExpire( false );
if( pItemBase->decrease_type == ItemBase::DECREASE_ON_GAME ||
pItemBase->decrease_type == ItemBase::DECREASE_ALWAYS )
bExpire = true;
else
bExpire = false;
if( nValue == -1 && bExpire )
return false;
if( nValue != -1 && bExpire && ( pItemBase->available_time < nValue ) )
return false;
}break;
case eCHECK_ITEM_EXPIRED_TIME_LE:
{
bool bExpire( false );
if( pItemBase->decrease_type == ItemBase::DECREASE_ON_GAME ||
pItemBase->decrease_type == ItemBase::DECREASE_ALWAYS )
bExpire = true;
else
bExpire = false;
if( nValue == -1 && bExpire )
return false;
if( nValue != -1 && bExpire && ( pItemBase->available_time > nValue ) )
return false;
}
break;
case eCHECK_ITEM_FIRST_SOCKET_CODE_MATCH:
{
const int nSocketCount( pItemBase->socket );
int const* pSocket( pSlot->GetSocketInfo() );
if( NULL < nSocketCount )
{
if( pSocket[0] != nValue )
return false;
}
}
break;
case eCHECK_ITEM_MAX_ETHEREAL_DURABILITY_E:
{
if( pSlot->getMaxEtherealDurability() != nValue )
return false;
}
break;
case eCHECK_ITEM_MAX_ETHEREAL_DURABILITY_NE:
{
if( pSlot->getMaxEtherealDurability() == nValue )
return false;
}
break;
case eCHECK_ITEM_TYPE:
{
if( pItemBase->nType != nValue )
return false;
}
break;
case eCHECK_MIX_CHECK_SAME_SUMMON_RATE:
{
if( ItemBase::GROUP_SUMMONCARD != pItemBase->nGroup )
return false;
if( GetCreatureDB().GetRate( pSlot->GetSummonID() ) != nValue )
return false;
}
break;
case eCHECK_MIX_CHECK_ENHANCE_GE:
{
if( pSlot->GetEnhance() < nValue )
return false;
}
break;
case eCHECK_MIX_CHECK_ENHANCE_LE:
{
if( pSlot->GetEnhance() > nValue )
return false;
}
break;
case eCHECK_MIX_CHECK_SAME_ITEM_GROUP:
{
if(pItemBase->nGroup != nValue )
return false;
}
break;
}
}
return true;
}
//-----------------------------------------------------------------------------------------------------------------
// 분해가 가능한 아이템 인가? ( 분해 DB로 부터 검사한다 )
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::IsPossibleDecompositionFromDB( const SInventorySlot* const pSlot, const ItemBaseEx_info* const pItemBase )
{
if( NULL == pSlot )
return false;
if( NULL == pItemBase )
return false;
SDecomposeDB::DECOMPOSE_FORMULA_LIST* const pDecomposeFormulaList( GetDecomposeDB().GetDecomposeFormula() );
if( NULL == pDecomposeFormulaList )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Decompose Formula Data From DB" );
assert( pDecomposeFormulaList );
return false;
}
m_n64NeedPriceTemporaryStorage = money_t( NULL );
for( SDecomposeDB::DECOMPOSE_FORMULA_ITER Iter = pDecomposeFormulaList->begin(); Iter != pDecomposeFormulaList->end(); ++Iter )
{
PDECOMPOSE_FORMULA_INFO pDecompositionFormula( Iter->second );
if( NULL == pDecompositionFormula )
{
SDEBUGLOG( "[SUIDecompositionWnd] Decompose Formula Pointer is Invalid" );
assert( pDecomposeFormulaList );
continue;
}
if( IsFindValidDecomositionFormula( pSlot, pItemBase, pDecompositionFormula ) )
{
m_n64NeedPriceTemporaryStorage = money_t( pDecompositionFormula->m_nNeedPrice );
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------------------------------------------
// 등록 가능 한 아이템 인가 ?
// 반환 값 : 예(true) / 아니요(false)
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::IsPossibleItemAppend( const ItemInstance::ItemUID n64UniqueID )
{
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( n64UniqueID ) );
if( NULL == pInventorySlot )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Slot Info By UniqueID - [ %u ]", n64UniqueID );
assert( pInventorySlot );
return false;
}
if( pInventorySlot )
{
const ItemBaseEx_info* pItemBase( GetItemDB().GetItemData( pInventorySlot->GetItemCode() ) );
if( NULL == pItemBase )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get ItemInfo - ItemCode [ %n ]", pInventorySlot->GetItemCode() );
assert( pItemBase );
return false;
}
else
{
// 분해 불가 Flag 체크
if( pItemBase->CheckFlag( ItemBase::FLAG_CANT_DECOMPOSE ) )
return false;
// 장비 중인 아이템인가?
if( pInventorySlot->IsEquipItem() )
return false;
// 소환수가 장비 중인 아이템 인가?
if( pInventorySlot->IsSummonEquip() )
return false;
// 강화 실패 아이템 인가?
if( pInventorySlot->GetXFlag().IsOn( ItemInstance::ITEM_FLAG_FAILED ) )
return false;
// 내구도가 0인 아이템 인가 ?
if( pInventorySlot->getMaxEtherealDurability() > 0 )
{
float fEthereal( pInventorySlot->GetEtherealDurability() );
if( fEthereal <= 0.0f )
return false;
}
int nGroup( pItemBase->nGroup );
// 장비 중인 스킬 카드 인가 ?
if( ItemBase::GROUP_SKILLCARD == nGroup )
{
if( m_InventoryMgr.IsEquipCard( pInventorySlot->GetHandle() ) )
return false;
}
// 소환되어 있는 펫 인가 ?
if( ItemBase::GROUP_PETCAGE == nGroup )
{
if( pInventorySlot->GetXFlag().IsOn( ItemInstance::ITEM_FLAG_CAGE_HAS_PET ) )
{
SGame* pGame( m_pGameManager->GetActiveGame() );
if( NULL == pGame )
return false;
DATA_PET* pPetData( pGame->IsLocalPetCage( pInventorySlot->GetHandle() ) );
if( NULL == pPetData )
return false;
if( pGame->IsSummonPet( pPetData->pet_handle ) )
return false;
}
}
// 크리쳐 카드인데 편성 되었거나 벨트에 장착되어 있나?
if( ItemBase::GROUP_SUMMONCARD == nGroup )
{
if( m_InventoryMgr.IsBeltSlotCard( pInventorySlot->GetHandle() ) )
return false;
if( m_CreatureSlotMgr.IsExistCreatureCard( pInventorySlot->GetHandle() ) )
return false;
}
if( false == IsPossibleDecompositionFromDB( pInventorySlot, pItemBase ) )
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------------------------------------------
// 열려 있으면 안되는 다른 UI가 열려 있는가 ?
// 설명 : 특정 UI가 열려 있을 경우 분해 UI가 열리면 안되기 때문에 여기서 체크한다.
// 반환 값 : 예(true) / 아니요(false)
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::IsOpenAnotherUIWindow()
{
if( NULL == m_pGameManager )
return true;
if( m_pGameManager->IsShow( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_TRADE ) )
return true;
if( m_pGameManager->IsShow( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_AUCTION ) )
return true;
if( m_pGameManager->IsShow( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_STORE_HOST ) )
return true;
return false;
}
//-----------------------------------------------------------------------------------------------------------------
// 경고 메시지 박스를 열어야 필요가 있는가 ?
// 반환 값 : 예(true) / 아니요(false)
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::IsNeedOpenCautionMessageBox( const ItemInstance::ItemUID n64UniqueID )
{
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( n64UniqueID ) );
if( NULL == pInventorySlot )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Slot Info By UniqueID - [ %u ]", n64UniqueID );
assert( pInventorySlot );
return false;
}
if( pInventorySlot )
{
const ItemBaseEx_info* pItemBase( GetItemDB().GetItemData( pInventorySlot->GetItemCode() ) );
if( NULL == pItemBase )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get ItemInfo - ItemCode [ %n ]", pInventorySlot->GetItemCode() );
assert( pItemBase );
return false;
}
else
{
if( NULL == m_pDisplayInfo )
return false;
// 강화
if( m_pDisplayInfo->IsEnhanceableItem( pInventorySlot->GetItemCode(), pItemBase ) )
{
int nEnhance( pInventorySlot->GetEnhance() );
// 스킬카드 강화
if( pItemBase->nGroup == ItemBase::GROUP_SKILLCARD )
{
if( 1 < nEnhance )
return true;
}
else
{
// 큐브 강화
if( NULL < pInventorySlot->GetEnhance() )
return true;
// 대장장이 강화
if( 1 < pInventorySlot->GetLevel() )
return true;
}
}
// 소울스톤
int nSocketCount( pInventorySlot->GetJewelSlotCount() );
int const* pSocket( pInventorySlot->GetSocketInfo() );
for( int nCount = 0; nCount < nSocketCount; nCount++ )
{
if( NULL == pSocket )
break;
int nJewelID( pSocket[nCount] );
if( nJewelID )
{
for( int nOptionCount = 0; nOptionCount < ItemBase::MAX_OPTION_NUMBER; nOptionCount++ )
{
int nType( NULL );
double dVar1( 0.0 ), dVar2( 0.0 );
if( GetItemDB().GetOptionVar( nJewelID, nOptionCount, nType, dVar1, dVar2 ) )
return true;
}
}
}
// 부여석 ( 0은 무속성 )
if( NULL != pInventorySlot->GetEET() )
return true;
// 봉인 된 크리쳐 카드
if( pInventorySlot->GetXFlag().IsOn( ItemInstance::ITEM_FLAG_SUMMON ) )
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------------------------------------------
// 동일한 유일한 아이템 아이디가 존재하는가 ?
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::IsExistItemUniqueID( const ItemInstance::ItemUID n64UniqueID )
{
for( ITER_ITEM_UNIQUE_ID_LIST Iter = m_mapUniqueID.begin(); Iter != m_mapUniqueID.end(); Iter++ )
{
const IN_DATA& kData = Iter->second;
ItemInstance::ItemUID nSaved64UniqueID( kData._id );
if( nSaved64UniqueID == n64UniqueID )
return true;
}
return false;
}
//-----------------------------------------------------------------------------------------------------------------
// 분해 할 아이템의 유니크 한 아아디를 등록한다.
//-----------------------------------------------------------------------------------------------------------------
bool SUIDecompositionWnd::SetAppendedItemToInventorySlot( const ItemInstance::ItemUID n64UniqueID, bool bAppend )
{
if( NULL == m_pGameManager )
return false;
if( NULL == n64UniqueID )
{
SDEBUGLOG( "[SUIDecompositionWnd] Item Unique ID is NULL" );
assert( n64UniqueID );
return false;
}
SUIInventoryWnd* pInventoryWnd( dynamicCast<SUIInventoryWnd*>( m_pGameManager->GetSUI(SIMSG_TOGGLE_UIWINDOW::UIWINDOW_INVENTORY) ) );
if( NULL == pInventoryWnd )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Inventory Window" );
assert( n64UniqueID );
return false;
}
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( n64UniqueID ) );
if( NULL == pInventorySlot )
{
SDEBUGLOG( "[SUIDecompositionWnd] Can't Get Slot Info By UniqueID - [ %u ]", n64UniqueID );
assert( pInventorySlot );
return false;
}
pInventorySlot->SetAppendDecomposeWnd( bAppend );
pInventoryWnd->RefreshInvenSlots();
return true;
}
//-----------------------------------------------------------------------------------------------------------------
// 분해 할 아이템의 유니크 한 아아디를 등록한다.
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::AppendItemUniqueID( const ItemInstance::ItemUID n64UniqueID )
{
if( NULL == n64UniqueID )
{
SDEBUGLOG( "[SUIDecompositionWnd] Item Unique ID is NULL" );
assert( n64UniqueID );
return ;
}
else
{
if( m_mapUniqueID.size() >= MAX_DECOMPOSITION_COUNT )
return;
if( IsExistItemUniqueID( n64UniqueID ) )
return;
if( IsPossibleItemAppend( n64UniqueID ) )
{
SInventorySlot* pInventorySlot( m_InventoryMgr.GetItemInfo( n64UniqueID ) );
if( NULL == pInventorySlot )
return;
if( pInventorySlot->GetItemCount() > 1 && m_bShiftKey ) // AziaMafia ADD KEY
{
m_n64WaitForAppendItemUniqueID = n64UniqueID;
count_t tMaxCount = ( pInventorySlot->GetItemCount() > MAX_EACH_COUNT ? count_t(MAX_EACH_COUNT) : pInventorySlot->GetItemCount() );
m_pGameManager->PostMsgAtDynamic( new SIMSG_UI_REQ_INPUTNUMBER( SIMSG_TOGGLE_UIWINDOW::UIWINDOW_DECOMPOSITION, tMaxCount, SIMSG_UI_REQ_INPUTNUMBER::TYPE_NUMBER ) );
}
else
{
if( IsNeedOpenCautionMessageBox( n64UniqueID ) )
{
if( NULL == m_pGameManager )
{
SDEBUGLOG( "[SUIDecompositionWnd] GameManager Pointer is NULL" );
assert( m_pGameManager );
return;
}
SGameInterface* pGameInterface( m_pGameManager->GetGameInterface() );
if( NULL == pGameInterface )
{
SDEBUGLOG( "[SUIDecompositionWnd] GameInterface Pointer is NULL" );
assert( pGameInterface );
return;
}
pGameInterface->OpenMessageBox( SIMSG_REQ_OPEN_MSGBOX::MSGBOX_YESNO, SIMSG_REQ_OPEN_MSGBOX::MSGBOX_DECOMPOSITON_CONFIRM_APPEND, false, -1, S( 1265 ) );
m_n64WaitForAppendItemUniqueID = n64UniqueID;
m_ntCountForWaiting = count_t(1); //gmpbigsun( 20130820, #27057 ) : 강화된 아이템 분해실패
}
else
{
WORD wIndex( m_mapUniqueID.size() );
IN_DATA kData;
kData._id = n64UniqueID;
kData._count = count_t(1);
if (m_bControlKey)
{
if ( pInventorySlot->GetItemCount() > 10 )
kData._count = count_t(10);
if (pInventorySlot->GetItemCount() < 10 && pInventorySlot->GetItemCount() > 1 )
kData._count = count_t(pInventorySlot->GetItemCount());
}
if (m_bAltKey)
{
kData._count = count_t(pInventorySlot->GetItemCount());
}
m_mapUniqueID.insert( make_pair<WORD, IN_DATA>( wIndex, kData ) );
AutoScrollBarMoveWhenAppendItem( wIndex );
SetAppendedItemToInventorySlot( n64UniqueID, true );
PCONTROL_INFO pFindControlInfo( FindControlInfo( wIndex ) );
if( pFindControlInfo )
pFindControlInfo->m_n64NeedPrice = m_n64NeedPriceTemporaryStorage;
}
}
}
else
{
if( m_pDisplayInfo ) m_pDisplayInfo->AddSystemMessage( S( 1263 ), 99 );
}
}
UpdateAppendedItemCount();
UpdateControlInfo();
UpdateItemInfo();
UpdateRupy();
UpdateButton();
}
//-----------------------------------------------------------------------------------------------------------------
// 아이템의 고유한 아이디를 삭제한다.
//-----------------------------------------------------------------------------------------------------------------
void SUIDecompositionWnd::DeleteItemUniqueID( const WORD wIndex )
{
ITER_ITEM_UNIQUE_ID_LIST FindIter = m_mapUniqueID.find( wIndex );
if( FindIter == m_mapUniqueID.end() )
return ;
IN_DATA kData = FindIter->second;
SetAppendedItemToInventorySlot( kData._id, false );
m_mapUniqueID.erase( wIndex );
vector<ItemInstance::ItemUID> vecTemp;
for( ITER_ITEM_UNIQUE_ID_LIST Iter = m_mapUniqueID.begin(); Iter != m_mapUniqueID.end(); Iter++ )
{
kData = Iter->second;
vecTemp.push_back( kData._id );
}
m_mapUniqueID.clear();
for( WORD wIndex = 0; wIndex < vecTemp.size(); wIndex++ )
{
IN_DATA kNewData;
kNewData._id = vecTemp[wIndex];
m_mapUniqueID.insert( make_pair<WORD, IN_DATA>( wIndex, kNewData ) );
}
}
Reference in New Issue View Git Blame Copy Permalink