Neo Source

[JerMTheSLayer]

feel so sad , this code not working in neo source :'( fatal error for server files only Reditor and bugtral.dll are show up after compiling..

ehhhh its easy to analyze what he shared and make it compatible to any source lol just patience and good eyes would do

asendure=pro :D

[JerMTheSLayer]

CHARACTER / VEHICLE / PET + DUAL SLOT WEAPON

CharacterWindow.cpp

#include "StdAfx.h"
#include "./CharacterWindow.h"
#include "DxGlobalStage.h"
#include "./GLCharClient.h"
#include "./GLFactEffect.h"
#include "./GLGaeaClient.h"

#include "../EngineUILib/GUInterface/BasicTextBox.h"
#include "../EngineUILib/GUInterface/BasicProgressBar.h"
#include "../EngineUILib/GUInterface/BasicButton.h"
#include "../EngineLib/DxCommon/d3dfont.h"
#include "GLCharacter.h"
#include "DxGameStage.h"
#include "../RanClientUILib/Interface/InnerInterface.h"

#include "../Interface/BasicTextButton.h"
#include "../Interface/UITextControl.h"
#include "../Interface/GameTextControl.h"
#include "../RanClientLib/G-Logic/GLGaeaClient.h"
#include "BasicComboBox.h"
#include "BasicComboBoxRollOver.h"

#include "DxEffectMan.h"
#include "DxEnvironment.h"
#include "DxSurfaceTex.h"
#include "DxGlowMan.h"
#include "DxPostProcess.h"
#include "DxCubeMap.h"
#include "DxSkyMan.h"
#include "DxEffGroupPlayer.h"
#include "../EngineLib/DxCommon/DxViewPort.h"
#include "../EngineLib/DxCommon/DxFontMan.h"
#include "../EngineLib/DxCommon/DxInputDevice.h"
#include "../EngineLib/DxCommon/DxLightMan.h"
#include "DxSkinChar.h"

#include "BasicLineBox.h"
#include "BasicTextBoxEx.h"
#include "InventoryPageWear.h"
#include "InventoryPageWearEx.h"
#include "VehicleWindow.h"
#include "PetWindow.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CCharacterWindow::CCharacterWindow () :
    m_pNameText ( NULL ),
    m_pLevelText ( NULL ),
    
    m_pButtonOk ( NULL ),
    m_pButtonCancel ( NULL ),

    m_pPageWear( NULL ),
    m_pPageWearEx( NULL ),
    m_pPetWindow( NULL ),
    m_pPointText ( NULL ),
    
    //Left
    m_pPowText ( NULL ),
    m_pDexText ( NULL ),
    m_pSpiText ( NULL ),
    m_pIntText ( NULL ),
    m_pStrText ( NULL ),
    m_pStaText ( NULL ),

    //Right
    m_pPowTextUp ( NULL ),
    m_pDexTextUp ( NULL ),
    m_pSpiTextUp ( NULL ),
    m_pIntTextUp ( NULL ),
    m_pStrTextUp ( NULL ),
    m_pStaTextUp ( NULL ),
    m_pClubText ( NULL ),

    m_pNewPow ( 0 ),
    m_pNewDex ( 0 ),
    m_pNewSpi ( 0 ),
    m_pNewStr ( 0 ),
    m_pNewSta ( 0 ),
    m_pNewPoint ( 0 ),
    nIndex ( 0 ),

    //Left
    m_pDamageHighText ( NULL ), //¤ÇÒÁáçÊÙ§ÊØ´
    m_pDamageLowText ( NULL ),    //¤ÇÒÁáçµèÓÊØ´
    m_pDefenseText ( NULL ),    //»éͧ¡Ñ¹
    m_pReqPaText ( NULL ),        //¶¹Ñ´
    m_pReqSaText ( NULL ),        //àÅç§
    m_pReqMaText ( NULL ),        //¾Åѧ§Ò¹
    m_pHitRateText ( NULL ),    //â¨ÁµÕ
    m_pAvoidRateText ( NULL ),    //ËźËÅÕ¡
    m_pHPText ( NULL ),            //HP
    m_pMPText ( NULL ),            //MP
    m_pSPText ( NULL ),            //SP

    //Right
    m_pDamageHighTextUp ( NULL ), //¤ÇÒÁáçÊÙ§ÊØ´
    m_pDamageLowTextUp ( NULL ),    //¤ÇÒÁáçµèÓÊØ´
    m_pDefenseTextUp ( NULL ),    //»éͧ¡Ñ¹
    m_pReqPaTextUp ( NULL ),        //¶¹Ñ´
    m_pReqSaTextUp ( NULL ),        //àÅç§
    m_pReqMaTextUp ( NULL ),        //¾Åѧ§Ò¹
    m_pHitRateTextUp ( NULL ),    //â¨ÁµÕ
    m_pAvoidRateTextUp ( NULL ),    //ËźËÅÕ¡
    m_pHPTextUp ( NULL ),            //HP
    m_pMPTextUp ( NULL ),            //MP
    m_pSPTextUp ( NULL ),            //SP

    m_pFireText ( NULL ),        //ä¿
    m_pColdText ( NULL ),        //¹éÓá¢ç§
    m_pElectricText ( NULL ),    //ä¿¿éÒ
    m_pPoisonText ( NULL ),        //¾ÔÉ
    m_pSpiritText ( NULL ),        //àÇ·Âì

    m_pPKStateText ( NULL ),
    m_pGradeText ( NULL ),        //ª×èÍàÊÕ§
    m_pGradeValue ( NULL ),        //ª×èÍàÊÕ§
    m_pBrightSlider ( NULL ),    //¤ÇÒÁ´Õ
    m_pActivityPointText ( NULL ),    //¼Å§Ò¹
    m_pActivityPointValue ( NULL ),    //¼Å§Ò¹
    m_pAcademy_Department ( NULL ),    //ʶҺѹ    //ÊÒÂÍÒªªÕ¾
    m_pd3dDevice ( NULL ),
    m_pMobileText( NULL ),
    m_pSkinChar(NULL)
{
    memset ( m_pPageButton, 0, sizeof ( m_pPageButton ) );
    memset ( m_pPageButton, 0, sizeof ( CBasicTextButton* ) * nMAXPAGENEW );

    memset ( m_pButtonPlus, 0, sizeof ( m_pButtonPlus ) );
    memset ( m_pButtonMinus, 0, sizeof ( m_pButtonMinus ) );
    D3DXMatrixIdentity( &m_matTrans );
}

CCharacterWindow::~CCharacterWindow ()
{
}


CBasicTextBox* CCharacterWindow::CreateStaticControl ( char* szControlKeyword, CD3DFontPar* pFont, int nAlign, const UIGUID& cID )
{
    CBasicTextBox* pStaticText = new CBasicTextBox;
    pStaticText->CreateSub ( this, szControlKeyword, UI_FLAG_DEFAULT, cID );
    pStaticText->SetFont ( pFont );
    pStaticText->SetTextAlign ( nAlign );    
    RegisterControl ( pStaticText );

    return pStaticText;
}

CBasicTextButton*  CCharacterWindow::CreateTextButton23 ( const char* szButton, UIGUID ControlID, const char* szText )
{
    const int nBUTTONSIZE = CBasicTextButton::SIZE23;
    CBasicTextButton* pTextButton = new CBasicTextButton;
    pTextButton->CreateSub ( this, "BASIC_TEXT_BUTTON23", UI_FLAG_XSIZE, ControlID );
    pTextButton->CreateBaseButton ( szButton, nBUTTONSIZE, CBasicButton::RADIO_FLIP, szText ,_DEFAULT_FONT_SHADOW_FLAG );
    RegisterControl ( pTextButton );
    return pTextButton;
}

CBasicTextButton*  CCharacterWindow::CreateTextButton24 ( const char* szButton, UIGUID ControlID, const char* szText )
{
    const int nBUTTONSIZE = CBasicTextButton::SIZE24;
    CBasicTextButton* pTextButton = new CBasicTextButton;
    pTextButton->CreateSub ( this, "BASIC_TEXT_BUTTON24", UI_FLAG_XSIZE, ControlID );
    pTextButton->CreateBaseButton ( szButton, nBUTTONSIZE, CBasicButton::CLICK_FLIP, szText , _DEFAULT_FONT_SHADOW_FLAG );
    RegisterControl ( pTextButton );
    return pTextButton;
}

CBasicTextButton*  CCharacterWindow::CreateTextButton25 ( const char* szButton, UIGUID ControlID, const char* szText )
{
    const int nBUTTONSIZE = CBasicTextButton::SIZE25;
    CBasicTextButton* pTextButton = new CBasicTextButton;
    pTextButton->CreateSub ( this, "BASIC_TEXT_BUTTON25", UI_FLAG_XSIZE, ControlID );
    pTextButton->CreateBaseButton ( szButton, nBUTTONSIZE, CBasicButton::CLICK_FLIP, szText , _DEFAULT_FONT_SHADOW_FLAG );
    RegisterControl ( pTextButton );
    return pTextButton;
}

void CCharacterWindow::CreateSubControl ()
{
    CD3DFontPar* pFont6Shadow = DxFontMan::GetInstance().LoadDxFont ( _DEFAULT_FONT, 7, _DEFAULT_FONT_SHADOW_FLAG );
    CD3DFontPar* pFont8Shadow = DxFontMan::GetInstance().LoadDxFont ( _DEFAULT_FONT, 8, _DEFAULT_FONT_SHADOW_FLAG );
    CD3DFontPar* pFont = DxFontMan::GetInstance().LoadDxFont ( _DEFAULT_FONT, 9, _DEFAULT_FONT_SHADOW_FLAG );
    CD3DFontPar* pFont10 = DxFontMan::GetInstance().LoadDxFont ( _DEFAULT_FONT, 10, _DEFAULT_FONT_SHADOW_FLAG );

    const EMCHARCLASS emCharClass = DxGlobalStage::GetInstance().GetGameStage()->GetCharJoinData().m_CharData2.m_emClass;
    const int nClassType = CharClassToIndex ( emCharClass );

    const int nAlignLeft = TEXT_ALIGN_LEFT;
    const int nAlignCenter = TEXT_ALIGN_CENTER_X;        
    const DWORD& dwSilver = NS_UITEXTCOLOR::SILVER;
    const DWORD& dwWhite = NS_UITEXTCOLOR::WHITE;
    const DWORD& dwSubTitle = NS_UITEXTCOLOR::PALEGOLDENROD;

    //¾×é¹ËÅѧÊÕ¢ÒÇ
    {
        m_bg_white = new CUIControl;
        m_bg_white->CreateSub ( this, "RNCHARACTER_WINDOW_REGION", UI_FLAG_DEFAULT);    
        m_bg_white->SetVisibleSingle ( TRUE );
        RegisterControl ( m_bg_white );
    }

    CString    strPageKeyword[nMAXPAGENEW] = 
    {
        "RNCHARACTER_WINDOW_CHAR_TAP",
        "RNCHARACTER_WINDOW_VEHICLE_TAP",
        "RNCHARACTER_WINDOW_PET_TAP",
    };        

    for ( int i = 0; i < nMAXPAGENEW; i++ )
    {        
        m_pPageButton[i] = CreateTextButton23 ( strPageKeyword[i].GetString (), RNCHARACTER_WINDOW_CHAR_TAP + i, (char*)ID2GAMEWORD ( "RNCHARACTER_WINDOW_CHAR_TAP", i ) );
    }
        

        
    {    
        // ¾×é¹ËÅѧ µÑÇÅФÃ
        m_pBackLine1 = new CBasicLineBox;
        m_pBackLine1->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pBackLine1->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_EQUIP_REGION" );
        RegisterControl ( m_pBackLine1 );

        //¾×é¹ËÅѧ ¢éÍÁÙÅÊèǹÅèÒ§
        m_pBackLine2 = new CBasicLineBox;
        m_pBackLine2->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pBackLine2->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_SCHOOL_REGION" );
        RegisterControl ( m_pBackLine2 );
    }

    {
        m_pStatusLine1 = new CBasicLineBox;
        m_pStatusLine1->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine1->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT1_REGION" );
        RegisterControl ( m_pStatusLine1 );    
    
        m_pStatusLine2 = new CBasicLineBox;
        m_pStatusLine2->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine2->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT2_REGION" );
        RegisterControl ( m_pStatusLine2 );    
    
        m_pStatusLine3 = new CBasicLineBox;
        m_pStatusLine3->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine3->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT3_REGION" );
        RegisterControl ( m_pStatusLine3 );
    }

    {
        m_pStatusLine4 = new CBasicLineBox;
        m_pStatusLine4->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine4->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT4_REGION" );
        RegisterControl ( m_pStatusLine4 );

        m_pStatusLine5 = new CBasicLineBox;
        m_pStatusLine5->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine5->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT5_REGION" );
        RegisterControl ( m_pStatusLine5 );

        m_pStatusLine6 = new CBasicLineBox;
        m_pStatusLine6->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine6->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT6_REGION" );
        RegisterControl ( m_pStatusLine6 );
    }

    {
        m_pStatusLine7 = new CBasicLineBox;
        m_pStatusLine7->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine7->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT7_REGION" );
        RegisterControl ( m_pStatusLine7 );

        m_pStatusLine8 = new CBasicLineBox;
        m_pStatusLine8->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine8->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT8_REGION" );
        RegisterControl ( m_pStatusLine8 );

        m_pStatusLine9 = new CBasicLineBox;
        m_pStatusLine9->CreateSub ( this, "BASIC_LINE_BOX_SKILL", UI_FLAG_XSIZE | UI_FLAG_YSIZE );
        m_pStatusLine9->CreateBaseBoxSkill ( "RNCHARACTER_WINDOW_STAT_POINT9_REGION" );
        RegisterControl ( m_pStatusLine9 );
    }

        m_pVehicleWindow = new CVehicleWindow;
        m_pVehicleWindow->CreateSub ( this, "CHARACTER_PAGE_VEHICLE", UI_FLAG_DEFAULT, CHARACTER_VEHICLEWINDOW );
        m_pVehicleWindow->CreateSubControl ();
        RegisterControl ( m_pVehicleWindow );
        
        m_pPetWindow = new CPetWindow;
        m_pPetWindow->CreateSub ( this, "CHARACTER_PAGE_PET", UI_FLAG_DEFAULT, CHARACTER_PETWINDOW );
        m_pPetWindow->CreateSubControl ();
        RegisterControl ( m_pPetWindow );

    {
        
        {
            m_pPageWear = new CInventoryPageWear;
            m_pPageWear->CreateSub ( this, "RNCHARACTER_WINDOW_WEAR_WINDOW", UI_FLAG_DEFAULT, CHARACTER_WINDOW_INVENTORY_PAGEWEAR );
            m_pPageWear->CreateSubControl ( nClassType );
            RegisterControl ( m_pPageWear );
            
        }
        
        {
            m_pPageWearEx = new CInventoryPageWearEx;
            m_pPageWearEx->CreateSub ( this, "RNCHARACTER_WINDOW_WEAR_WINDOW", UI_FLAG_DEFAULT, CHARACTER_WINDOW_INVENTORY_PAGEWEAR_EX );
            m_pPageWearEx->CreateSubControl ( nClassType );
            RegisterControl ( m_pPageWearEx );
    
            SetVisiblePage ( 0 );
        }
    }    

        
        
        
    
        
            
    
            
    
    m_pAcademy_Department = CreateStaticControl ( "RNCHARACTER_WINDOW_ACADEMY_DEPARTMENT_TEXT", pFont, nAlignLeft );
    
    CBasicTextBox* pTextBox = CreateStaticControl ( "RNCHARACTER_WINDOW_BRIGHT_TEXT", pFont8Shadow, nAlignLeft );
    pTextBox->AddText ( ID2GAMEWORD("CHARACTER_SOCIAL_STATIC", 5), dwWhite );

    m_pGradeText = CreateStaticControl ( "RNCHARACTER_WINDOW_CONTRIBUTION_POINT_TEXT", pFont8Shadow, nAlignLeft );
    m_pGradeValue = CreateStaticControl ( "RNCHARACTER_WINDOW_CONTRIBUTION_POINT_VALUE", pFont8Shadow, nAlignLeft );
    
    m_pActivityPointText = CreateStaticControl ( "RNCHARACTER_WINDOW_ACTIVITY_POINT_TEXT", pFont8Shadow, nAlignLeft );
    m_pActivityPointValue = CreateStaticControl ( "RNCHARACTER_WINDOW_ACTIVITY_POINT_VALUE", pFont8Shadow, nAlignLeft );
    
    m_pBrightFrame = CreateControl ( "RNCHARACTER_WINDOW_BRIGHTBAR",CHARACTER_BIRGHTER );        
    m_pBrightSlider = CreateControl ( "RNCHARACTER_WINDOW_BRIGHTBAR_THUMB" );

    m_pPointTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_POINT_TEXT", pFont, nAlignLeft );
    m_pPointText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_POINT_VALUE", pFont, nAlignLeft );

    m_pPointTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STAT_POINT"), dwWhite );

    m_pPowTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_POW_TEXT", pFont6Shadow, nAlignLeft );
    m_pDexTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_DEX_TEXT", pFont6Shadow, nAlignLeft );
    m_pSpiTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_SPI_TEXT", pFont6Shadow, nAlignLeft );
    m_pStrTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_STR_TEXT", pFont6Shadow, nAlignLeft );
    m_pStaTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_STA_TEXT", pFont6Shadow, nAlignLeft );

    m_pPowTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STAT_STATIC", 0), dwWhite );
    m_pDexTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STAT_STATIC", 1), dwWhite );
    m_pSpiTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STAT_STATIC", 2), dwWhite );
    m_pStrTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STAT_STATIC", 4), dwWhite );
    m_pStaTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STAT_STATIC", 5), dwWhite );

    m_pPowText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_POW_VALUE", pFont6Shadow, nAlignCenter );
    m_pDexText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_DEX_VALUE", pFont6Shadow, nAlignCenter );
    m_pSpiText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_SPI_VALUE", pFont6Shadow, nAlignCenter );
    m_pStrText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_STR_VALUE", pFont6Shadow, nAlignCenter );
    m_pStaText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_STA_VALUE", pFont6Shadow, nAlignCenter );

    m_pPowTextUp = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_POW_UP_VALUE", pFont6Shadow, nAlignCenter );
    m_pDexTextUp = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_DEX_UP_VALUE", pFont6Shadow, nAlignCenter );
    m_pSpiTextUp = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_SPI_UP_VALUE", pFont6Shadow, nAlignCenter );
    m_pStrTextUp = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_STR_UP_VALUE", pFont6Shadow, nAlignCenter );
    m_pStaTextUp = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_1_STA_UP_VALUE", pFont6Shadow, nAlignCenter );

    CString    strButtonPlus[5] = 
    {
        "RNCHARACTER_WINDOW_STAT_POW_PLUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_DEX_PLUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_SPI_PLUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_STR_PLUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_STA_PLUS_BUTTON"
    };

    CString    strButtonMinus[5] = 
    {
        "RNCHARACTER_WINDOW_STAT_POW_MINUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_DEX_MINUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_SPI_MINUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_STR_MINUS_BUTTON",
        "RNCHARACTER_WINDOW_STAT_STA_MINUS_BUTTON"
    };

    for ( int i = 0; i < 5; i++ )
    {    
        m_pButtonPlus[i] = CreateTextButton24 ( strButtonPlus[i].GetString (), CHARACTER_WINDOW_STAT_POW_PLUS_BUTTON + i, "+" );
        m_pButtonMinus[i] = CreateTextButton24 ( strButtonMinus[i].GetString (), CHARACTER_WINDOW_STAT_POW_MINUS_BUTTON + i, "-" );
    }

    m_pButtonOk = CreateTextButton25 ( "RNCHARACTER_WINDOW_STAT_APPLY_BUTTON", CHARACTER_WINDOW_STAT_OK , ID2GAMEWORD("CHARACTER_STAT_APPLY") );
    m_pButtonCancel = CreateTextButton25 ( "RNCHARACTER_WINDOW_STAT_INIT_BUTTON", CHARACTER_WINDOW_STAT_CANCEL , ID2GAMEWORD("CHARACTER_STAT_INIT") );

    m_pDamageHighTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_ATTACK_MAX_TEXT", pFont6Shadow, nAlignLeft );
    m_pDamageLowTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_ATTACK_MIN_TEXT", pFont6Shadow, nAlignLeft );
    m_pDefenseTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_DEFENSE_TEXT", pFont6Shadow, nAlignLeft );
    m_pReqPaTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_FIGHT_TEXT", pFont6Shadow, nAlignLeft );
    m_pReqSaTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_SHOOT_TEXT", pFont6Shadow, nAlignLeft );
    m_pReqMaTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_STAMINA_TEXT", pFont6Shadow, nAlignLeft );
    m_pHitRateTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_HIT_TEXT", pFont6Shadow, nAlignLeft );
    m_pAvoidRateTextv = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_AVOID_TEXT", pFont6Shadow, nAlignLeft );
    m_pHPTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_HP_TEXT", pFont6Shadow, nAlignLeft );
    m_pMPTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_MP_TEXT", pFont6Shadow, nAlignLeft );
    m_pSPTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_SP_TEXT", pFont6Shadow, nAlignLeft );
    
    m_pDamageHighTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 14), dwWhite );
    m_pDamageLowTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 15), dwWhite );
    m_pDefenseTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 3), dwWhite );
    m_pReqPaTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 4), dwWhite );
    m_pReqSaTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 5), dwWhite );
    m_pReqMaTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 11), dwWhite );
    m_pHitRateTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 9), dwWhite );
    m_pAvoidRateTextv->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 10), dwWhite );
    m_pHPTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 16), dwWhite );
    m_pMPTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 17), dwWhite );
    m_pSPTextStatic->AddText ( ID2GAMEWORD("CHARACTER_STATUS_STATIC", 18), dwWhite );

    m_pDamageHighText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_ATTACK_MAX_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pDamageLowText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_ATTACK_MIN_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pDefenseText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_DEFENSE_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pReqPaText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_FIGHT_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pReqSaText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_SHOOT_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pReqMaText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_STAMINA_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pHitRateText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_HIT_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pAvoidRateText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_AVOID_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pHPText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_HP_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pMPText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_MP_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );
    m_pSPText  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_SP_VALUE", pFont6Shadow, TEXT_ALIGN_RIGHT );

    /*m_pDamageHighTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_ATTACK_MAX_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pDamageLowTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_ATTACK_MIN_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pDefenseTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_DEFENSE_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pReqPaTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_FIGHT_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pReqSaTextUp    = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_SHOOT_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pReqMaTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_STAMINA_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pHitRateTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_HIT_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pAvoidRateTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_AVOID_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pHPTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_HP_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pMPTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_MP_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );
    m_pSPTextUp  = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_2_SP_UP_VALUE", pFont8Shadow, TEXT_ALIGN_RIGHT );*/

    m_pFireTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_FIRE_RESIST_TEXT", pFont6Shadow, nAlignLeft );
    m_pColdTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_COLD_RESIST_TEXT", pFont6Shadow, nAlignLeft );
    m_pElectricTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_ELECTRIC_RESIST_TEXT", pFont6Shadow, nAlignLeft );
    m_pPoisonTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_POISON_RESIST_TEXT", pFont6Shadow, nAlignLeft );
    m_pSpiritTextStatic = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_SPIRIT_RESIST_TEXT", pFont6Shadow, nAlignLeft );

    m_pFireTextStatic->AddText ( ID2GAMEWORD("CHARACTER_RESI_STATIC", 1), dwWhite );
    m_pColdTextStatic->AddText ( ID2GAMEWORD("CHARACTER_RESI_STATIC", 2), dwWhite );
    m_pElectricTextStatic->AddText ( ID2GAMEWORD("CHARACTER_RESI_STATIC", 3), dwWhite );
    m_pPoisonTextStatic->AddText ( ID2GAMEWORD("CHARACTER_RESI_STATIC", 4), dwWhite );
    m_pSpiritTextStatic->AddText ( ID2GAMEWORD("CHARACTER_RESI_STATIC", 5), dwWhite );

    m_pFireText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_FIRE_RESIST_VALUE", pFont6Shadow, nAlignLeft );
    m_pColdText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_COLD_RESIST_VALUE", pFont6Shadow, nAlignLeft );
    m_pElectricText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_ELECTRIC_RESIST_VALUE", pFont6Shadow, nAlignLeft );
    m_pPoisonText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_POISON_RESIST_VALUE", pFont6Shadow, nAlignLeft );
    m_pSpiritText = CreateStaticControl ( "RNCHARACTER_WINDOW_STAT_3_SPIRIT_RESIST_VALUE", pFont6Shadow, nAlignLeft );

    m_pLevelText = CreateStaticControl ( "CHARACTER_LEVEL_AND_NAME_TEXT", pFont8Shadow, TEXT_ALIGN_CENTER_X );
    m_pClubText = CreateStaticControl ( "CHARACTER_CLUB_TEXT", pFont8Shadow, TEXT_ALIGN_CENTER_X );

}
CBasicTextButton*  CCharacterWindow::CreateTextButton ( const char* szButton, UIGUID ControlID, const char* szText )
{
    const int nBUTTONSIZE = CBasicTextButton::SIZE23;
    CBasicTextButton* pTextButton = new CBasicTextButton;
    pTextButton->CreateSub ( this, "BASIC_TEXT_BUTTON23", UI_FLAG_XSIZE, ControlID );
    pTextButton->CreateBaseButton ( szButton, nBUTTONSIZE, CBasicButton::RADIO_FLIP, szText );
    RegisterControl ( pTextButton );
    return pTextButton;
}

void CCharacterWindow::SetGlobalPos(const D3DXVECTOR2& vPos)
{
    CUIGroup::SetGlobalPos( vPos );
    const GLCHARLOGIC& sCharData = GLGaeaClient::GetInstance().GetCharacterLogic ();    
    
    SetBright( sCharData );
}

HRESULT CCharacterWindow::InitDeviceObjects ( LPDIRECT3DDEVICEQ pd3dDevice )
{
    GASSERT( pd3dDevice );
    m_pd3dDevice = pd3dDevice;

    HRESULT hr = S_OK;
    {
        hr = CUIWindowEx::InitDeviceObjects( pd3dDevice );
        //hr = m_pd3dDevice->GetDeviceCaps ( &m_d3dCaps );
        if ( FAILED ( hr ) ) return hr;
    }
    m_CharacterNew = GLGaeaClient::GetInstance().GetCharacter();

    D3DXVECTOR3 m_vPos = D3DXVECTOR3(12.0f,-135.0f,400.0f);
    D3DXVECTOR3    m_vDir = m_CharacterNew->GetDirectionVector();
    D3DXVECTOR3 m_vDirOrig = m_CharacterNew->GetOrig();

    //D3DXMATRIX matTrans, matYRot;
    //D3DXMatrixTranslation ( &matTrans, m_vPos.x, m_vPos.y, m_vPos.z );
    //float fThetaY = DXGetThetaYFromDirection ( m_vDir, m_vDirOrig );
    //D3DXMatrixRotationY ( &matYRot, fThetaY );

    EMCHARINDEX emIndex = CharClassToIndex( m_CharacterNew->m_emClass );
    DxSkinCharData* pSkinChar = DxSkinCharDataContainer::GetInstance().LoadData( GLCONST_CHAR::szCharSkin[emIndex], m_pd3dDevice, TRUE );
    if ( !pSkinChar )    return E_FAIL;

    SAFE_DELETE( m_pSkinChar );
    m_pSkinChar = new DxSkinChar;
    m_pSkinChar->SetCharData ( pSkinChar, m_pd3dDevice, TRUE );
    UpdateSuit ();

    return S_OK;
}
BOOL CCharacterWindow::IsCurUseArm( EMSLOT emSlot )
{
    if( IsUseArmSub() )
    {
        if( emSlot == SLOT_RHAND || emSlot == SLOT_LHAND ) return FALSE;
    }
    else
    {




        if( emSlot == SLOT_RHAND_S || emSlot == SLOT_LHAND_S ) return FALSE;
    }


    return TRUE;
}

HRESULT CCharacterWindow::UpdateSuit ()
{
    GASSERT( m_pd3dDevice );

    EMCHARINDEX emIndex = CharClassToIndex( m_CharacterNew->m_emClass );
    DxSkinCharData* pSkinChar = DxSkinCharDataContainer::GetInstance().FindData ( GLCONST_CHAR::szCharSkin[emIndex] );
    if ( !pSkinChar )    return E_FAIL;

    


    const GLCONST_CHARCLASS &sCONST = GLCONST_CHAR::cCONSTCLASS[emIndex];



    if ( sCONST.dwHEADNUM > m_CharacterNew->m_wFace )
    {
        std::string strHEAD_CPS = sCONST.strHEAD_CPS[m_CharacterNew->m_wFace];
    


        PDXCHARPART pCharPart = NULL;
        pCharPart = m_pSkinChar->GetPiece(PIECE_HEAD);        //    ÇöÁ¦ ÀåÂø ½ºÅ².

        if ( pCharPart && strcmp(strHEAD_CPS.c_str(),pCharPart->GetFileName()) )
        {
            m_pSkinChar->SetPiece ( strHEAD_CPS.c_str(), m_pd3dDevice, 0x0, 0, TRUE );
        }
    }

    if ( sCONST.dwHAIRNUM > m_CharacterNew->m_wHair )
    {
        std::string strHAIR_CPS = sCONST.strHAIR_CPS[m_CharacterNew->m_wHair];
    


        PDXCHARPART pCharPart = NULL;
        pCharPart = m_pSkinChar->GetPiece(PIECE_HAIR);        //    ÇöÁ¦ ÀåÂø ½ºÅ².



        if ( pCharPart && strcmp(strHAIR_CPS.c_str(),pCharPart->GetFileName()) )
        {
            m_pSkinChar->SetPiece ( strHAIR_CPS.c_str(), m_pd3dDevice, 0x0, 0, TRUE );
        }
    }


    m_pSkinChar->SetHairColor( m_CharacterNew->m_wHairColor );






    for ( int i=0; i<SLOT_NSIZE_S_2; i++ )
    {
        // ÇöÀç ÀåÂøÁßÀÎ ¹«±â°¡ ¾Æ´Ï¸é ³Ñ¾î°£´Ù.
        if( !IsCurUseArm( EMSLOT(i) ) ) continue;






        SITEMCUSTOM &ItemClient = m_CharacterNew->m_PutOnItems[i];






        SNATIVEID nidITEM = ItemClient.nidDISGUISE;
        if ( nidITEM==SNATIVEID(false) )    nidITEM = ItemClient.sNativeID;






        /*if ( !m_bVehicle && i == SLOT_VEHICLE  ) nidITEM = SNATIVEID(false);
        else if ( i == SLOT_VEHICLE )
        {
            nidITEM = m_sVehicle.GetSkinID();
            if ( nidITEM == SNATIVEID(false) )
            {
                m_sVehicle.m_sVehicleID = ItemClient.sNativeID;
                nidITEM = ItemClient.sNativeID;
            }
        }*/


        if ( nidITEM == SNATIVEID(false) )
        {
            //    Note : ±âº» ½ºÅ²°ú Áö±Ý ÀåÂøµÈ ½ºÅ²ÀÌ Æ²¸± °æ¿ì.
            //    SLOT->PIECE.
            PDXSKINPIECE pSkinPiece = NULL;    //    ±âº» ½ºÅ².
            PDXCHARPART pCharPart = NULL;    //    ÇöÁ¦ ÀåÂø ½ºÅ².

            EMPIECECHAR emPiece = SLOT_2_PIECE(EMSLOT(i));
            if ( emPiece!=PIECE_SIZE )
            {
                pSkinPiece = pSkinChar->GetPiece(emPiece);    //    ±âº» ½ºÅ².
                pCharPart = m_pSkinChar->GetPiece(emPiece);    //    ÇöÁ¦ ÀåÂø ½ºÅ².
            }

            if ( pSkinPiece )
            {
                if ( pCharPart && strcmp(pSkinPiece->m_szFileName,pCharPart->GetFileName()) )
                    m_pSkinChar->SetPiece ( pSkinPiece->m_szFileName, m_pd3dDevice, 0x0, 0, TRUE );
            }
            else
            {
                if ( pCharPart )    m_pSkinChar->ResetPiece(emPiece);
            }
        }
        else
        {
            SITEM* pItem = GLItemMan::GetInstance().GetItem ( nidITEM );
            if ( pItem )
            {
                m_pSkinChar->SetPiece ( pItem->GetWearingFile(emIndex), m_pd3dDevice, NULL, ItemClient.GETGRADE_EFFECT(), TRUE );
            }
        }
    }

    /*if( m_dwTransfromSkill != SNATIVEID::ID_NULL )
    {






        PGLSKILL pSkill = GLSkillMan::GetInstance().GetData ( m_sSKILLFACT[m_dwTransfromSkill].sNATIVEID.wMainID, m_sSKILLFACT[m_dwTransfromSkill].sNATIVEID.wSubID );
        if( pSkill ) 
        {
            for( BYTE i = 0; i < SKILL::EMTRANSFORM_NSIZE; i++ )
            {
                if( m_CharData.wSex == 1 )
                {                
                    m_pSkinChar->SetPiece ( pSkill->m_sSPECIAL_SKILL.strTransform_Man[i].c_str(), m_pd3dDevice, 0X0, 0, TRUE );
                }else{
                    m_pSkinChar->SetPiece ( pSkill->m_sSPECIAL_SKILL.strTransform_Woman[i].c_str(), m_pd3dDevice, 0X0, 0, TRUE );
                }
            }
        }
    }



    //    Note : ½ºÅ³ ¹öÇÁ, »óÅÂÀÌ»ó È¿°ú »ý¼º.
    FACTEFF::ReNewEffect ( STARGETID(CROW_PC,m_dwGaeaID,m_vPos), m_pSkinChar, m_sSKILLFACT, m_sSTATEBLOWS, m_matTrans, m_vDir );

    if( GLCONST_CHAR::cCONSTCLASS[emIndex].strCLASS_EFFECT.size() != 0 )
    {






        DxEffcharDataMan::GetInstance().PutPassiveEffect ( m_pSkinChar, GLCONST_CHAR::cCONSTCLASS[emIndex].strCLASS_EFFECT.c_str(), &m_vDir );
    }*/





    return S_OK;
}



HRESULT CCharacterWindow::FrameMove ( float fTime, float fElapsedTime )
{
    GASSERT( m_pd3dDevice );

    D3DXVECTOR3 vFromPt        = DxViewPort::GetInstance().GetFromPt();
    D3DXVECTOR3 vLookatPt    = DxViewPort::GetInstance().GetLookatPt();
    D3DXVECTOR3 vUpVec        = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );

    m_pSkinChar->FrameMove( fTime,fElapsedTime );

    D3DXMATRIX matTrans , matYRot;
    D3DXMatrixTranslation ( &matTrans, vLookatPt.x, vLookatPt.y, vLookatPt.z );
    float fThetaY = DXGetThetaYFromDirection ( vUpVec, vFromPt );
    D3DXMatrixRotationY ( &matYRot, fThetaY );

    // Get D3DX to fill in the matrix values
    D3DXMATRIX matView;
    D3DXMatrixLookAtLH( &matView, &vFromPt, &vLookatPt, &vUpVec );

    // Set our view matrix
    //m_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );

    m_matTrans = matTrans ;

    return S_OK;
}


HRESULT    CCharacterWindow::Render ( LPDIRECT3DDEVICEQ pd3dDevice, CLIPVOLUME &cv, BOOL bRendAABB )
{
    GASSERT( pd3dDevice );
    CLIPVOLUME &CV = DxViewPort::GetInstance().GetClipVolume ();

//    if ( m_bNeedData && !(m_dwRevData&RECEIVE_CHARDATA) )    return S_FALSE;
    if ( !m_pSkinChar )                                        return S_FALSE;

    if ( bRendAABB ) EDITMESHS::RENDERAABB ( pd3dDevice, m_vMax, m_vMin );    //    Å×½ºÆ®¿ë.
    if( !IsVisible() ) return S_OK;


    HRESULT hr = S_OK;
hr = CUIWindowEx::Render ( pd3dDevice );
        if ( FAILED ( hr ) ) return hr;

    return S_OK;
}

void CCharacterWindow::SetArmSwapTabButton( BOOL bArmSub )
{
    if( m_pPageWearEx )
    {
        m_pPageWearEx->SetTabButton( bArmSub );
    }
}
void CCharacterWindow::SetVisiblePage ( int nPage )
{
    const EMCHARCLASS emCharClass = DxGlobalStage::GetInstance().GetGameStage()->GetCharJoinData().m_CharData2.m_emClass;
    const int nClassType = CharClassToIndex ( emCharClass );

    for ( int i = 0; i < nMAXPAGENEW; i++ )
    {
        m_pPageButton[i]->SetFlip ( FALSE );        
    }
    
    m_pPageWear->SetVisibleSingle ( FALSE );
    m_pPageWearEx->SetVisibleSingle ( FALSE );
    m_pVehicleWindow->SetVisibleSingle ( FALSE );
    m_pPetWindow->SetVisibleSingle ( FALSE );
    
    if ( nPage == 2 )
    {
        m_pPageButton[2]->SetFlip ( TRUE );
        m_pPetWindow->SetVisibleSingle ( TRUE );
    }
     else if ( nPage == 1 )
    {
        m_pPageButton[1]->SetFlip ( TRUE );
        m_pVehicleWindow->SetVisibleSingle ( TRUE );
    }
    else if ( nPage == 0 )
    {
        m_pPageButton[0]->SetFlip ( TRUE );
        m_pPageWear->SetVisibleSingle ( TRUE );
        m_pPageWearEx->SetVisibleSingle ( TRUE );
    }

}

CharacterWindow.h

#pragma    once

#include "../Interface/UIWindowEx.h"
#include "DxCharSham.h"
#include "DxLandMan.h"
#include "GLCharacter.h"
#include "../../EngineLib/Meshs/DxSkinChar.h"

class    CD3DFontPar;
class    CBasicProgressBar;
class    CBasicTextBox;
class    CBasicTextButton;
class    CBasicButton;
class    CBasicLineBox;
struct    GLCHARLOGIC;
class    CInventoryPageWear;
class    CInventoryPageWearEx;
class    GLCharacter;
class    DxCharSham;
class    CBasicComboBox;
class    CBasicComboBoxRollOver;
class    DxLandMan;
class    DxSkinCharData;
class    CPetWindow;
class    CVehicleWindow;

class CCharacterWindow : public CUIWindowEx 
{

protected:
    enum
    {
        nMAXPAGENEW = 3
    };
    enum
    { 
        RNCHARACTER_WINDOW_CHAR_TAP = ET_CONTROL_NEXT,
        RNCHARACTER_WINDOW_VEHICLE_TAP,
        RNCHARACTER_WINDOW_PET_TAP,
        CHARACTER_BIRGHTER,
        CHARACTER_WINDOW_STAT_POW_PLUS_BUTTON,
        CHARACTER_WINDOW_STAT_DEX_PLUS_BUTTON,
        CHARACTER_WINDOW_STAT_SPI_PLUS_BUTTON,
        CHARACTER_WINDOW_STAT_STR_PLUS_BUTTON,
        CHARACTER_WINDOW_STAT_STA_PLUS_BUTTON,
        CHARACTER_WINDOW_STAT_POW_MINUS_BUTTON,
        CHARACTER_WINDOW_STAT_DEX_MINUS_BUTTON,
        CHARACTER_WINDOW_STAT_SPI_MINUS_BUTTON,
        CHARACTER_WINDOW_STAT_STR_MINUS_BUTTON,
        CHARACTER_WINDOW_STAT_STA_MINUS_BUTTON,
        CHARACTER_WINDOW_STAT_OK,
        CHARACTER_WINDOW_STAT_CANCEL,
        CHARACTER_WINDOW_INVENTORY_PAGEWEAR,
        CHARACTER_WINDOW_INVENTORY_PAGEWEAR_EX,
        CHARACTER_VEHICLEWINDOW,
        CHARACTER_PETWINDOW,
    };

public:
    CCharacterWindow ();
    virtual    ~CCharacterWindow ();


public:
virtual HRESULT InitDeviceObjects ( LPDIRECT3DDEVICEQ pd3dDevice );
    virtual    HRESULT    Render  ( LPDIRECT3DDEVICEQ pd3dDevice, CLIPVOLUME &cv, BOOL bRendAABB );
    virtual void Update ( int x, int y, BYTE LB, BYTE MB, BYTE RB, int nScroll, float fElapsedTime, BOOL bFirstControl );
    virtual    void TranslateUIMessage ( UIGUID ControlID, DWORD dwMsg );
    virtual    void SetVisibleSingle ( BOOL bVisible );
    virtual void SetGlobalPos(const D3DXVECTOR2& vPos);
    virtual HRESULT FrameMove ( float fTime, float fElapsedTime );
    virtual HRESULT UpdateSuit ();

public:
    void    CreateSubControl ();

    void    LoadComboData ();
    void    LoadItem ();


    GLCharacter*        m_CharacterNew;
    DxCharSham            m_NewCharSham;
    D3DCAPSQ            m_d3dCaps;
    D3DSURFACE_DESC        m_d3dsdBackBuffer;
    DxLandMan            m_LandLogin;

    DxSkinChar*            m_pSkinChar;
    D3DXMATRIX            m_matTrans;
    D3DXVECTOR3            m_vMaxOrg;
    D3DXVECTOR3            m_vMinOrg;
    D3DXVECTOR3            m_vDir;
    D3DXVECTOR3            m_vDirOrig;
    D3DXVECTOR3            m_vPos;
    D3DXVECTOR3            m_vMax;
    D3DXVECTOR3            m_vMin;

    BOOL    IsCurUseArm( EMSLOT emSlot );
    BOOL IsUseArmSub() const            { return m_CharacterNew->m_bUseArmSub; }
private:
    CBasicTextBox*        CreateStaticControl ( char* szConatrolKeyword, CD3DFontPar* pFont, int nAlign, const UIGUID& cID = NO_ID );
    CBasicTextButton*    CreateTextButton23 ( const char* szButton, UIGUID ControlID, const char* szText );
    CBasicTextButton*    CreateTextButton24 ( const char* szButton, UIGUID ControlID, const char* szText );
    CBasicTextButton*    CreateTextButton25 ( const char* szButton, UIGUID ControlID, const char* szText );

//private:
//    void    SetPointControl ( BOOL bPointUsable );
//
private:    //    À̸§,Ŭ·¡½º
    void    SetName ( const GLCHARLOGIC& sCharData );
    void    SetLevel ( const GLCHARLOGIC& sCharData );
//
private:    //    Stat
    void    SetPow ( const GLCHARLOGIC& sCharData );
    void    SetDex ( const GLCHARLOGIC& sCharData );
    void    SetSpi ( const GLCHARLOGIC& sCharData );
    void    SetStr ( const GLCHARLOGIC& sCharData );
    void    SetSta ( const GLCHARLOGIC& sCharData );

    void    SetPowUp ( int num,const GLCHARLOGIC& sCharData );
    void    SetDexUp ( int num,const GLCHARLOGIC& sCharData );
    void    SetSpiUp ( int num,const GLCHARLOGIC& sCharData );
    void    SetStrUp ( int num,const GLCHARLOGIC& sCharData );
    void    SetStaUp ( int num,const GLCHARLOGIC& sCharData );
    void    SetPoint ( const GLCHARLOGIC& sCharData );
//
private:    //    Status
    void    SetDamage ( const GLCHARLOGIC& sCharData );
    void    SetDefense ( const GLCHARLOGIC& sCharData );
    void    SetReqPa ( const GLCHARLOGIC& sCharData );
    void    SetReqSa ( const GLCHARLOGIC& sCharData );
    void    SetReqMa ( const GLCHARLOGIC& sCharData );
    void    SetHitRate ( const GLCHARLOGIC& sCharData );
    void    SetAvoidRate ( const GLCHARLOGIC& sCharData );
    void    SetHP ( const GLCHARLOGIC& sCharData );
    void    SetMP ( const GLCHARLOGIC& sCharData );
    void    SetSP ( const GLCHARLOGIC& sCharData );

    void    SetFireResi ( const GLCHARLOGIC& sCharData );
    void    SetColdResi ( const GLCHARLOGIC& sCharData );
    void    SetElectricResi ( const GLCHARLOGIC& sCharData );
    void    SetPoisonResi ( const GLCHARLOGIC& sCharData );
    void    SetSpiritResi ( const GLCHARLOGIC& sCharData );

    void    SetBright ( const GLCHARLOGIC& sCharData );
//    void    SetPKState ( const GLCHARLOGIC& sCharData );
    void    SetGrade ( const GLCHARLOGIC& sCharData );
    void    SetActivityPoint ( const GLCHARLOGIC& sCharData );    //    »ýÈ°Á¡¼ö
    void    SetAcademy_Department ( const GLCHARLOGIC& sCharData );        //    Çб³
    void    SetNumber2 ( int nIndex, int nNumber );
    void    SetNumber3 ( int nIndex, int nNumber );
    void    ResetNumber ( int nIndex );

private:
    LPDIRECT3DDEVICEQ    m_pd3dDevice;
    GLCharacter*        m_pCharacter;
    CBasicTextBox*        m_pNameText;


private:    //    Stats
    CBasicButton*    m_pButtonPlus[5];
    CBasicButton*    m_pButtonMinus[5];

    CBasicButton*    m_pButtonOk;
    CBasicButton*    m_pButtonCancel;

    CBasicTextBox*    m_pPowText;
    CBasicTextBox*    m_pDexText;
    CBasicTextBox*    m_pSpiText;
    CBasicTextBox*    m_pIntText;
    CBasicTextBox*    m_pStrText;
    CBasicTextBox*    m_pStaText;

    CBasicTextBox*    m_pPowTextUp;
    CBasicTextBox*    m_pDexTextUp;
    CBasicTextBox*    m_pSpiTextUp;
    CBasicTextBox*    m_pIntTextUp;
    CBasicTextBox*    m_pStrTextUp;
    CBasicTextBox*    m_pStaTextUp;

    CBasicTextBox*    m_pPowTextStatic;
    CBasicTextBox*    m_pDexTextStatic;
    CBasicTextBox*    m_pSpiTextStatic;
    CBasicTextBox*    m_pIntTextStatic;
    CBasicTextBox*    m_pStrTextStatic;
    CBasicTextBox*    m_pStaTextStatic;

    CBasicTextBox*    m_pPointTextStatic;
    CBasicTextBox*    m_pPointText;

    int        m_pNewPow;
    int        m_pNewDex;
    int        m_pNewSpi;
    int        m_pNewStr;
    int        m_pNewSta;
    int        m_pNewPoint;
    int        nIndex;


    CInventoryPageWear*    m_pPageWear;
    CInventoryPageWearEx* m_pPageWearEx;

private:    //    Status
    CBasicTextBox*    m_pLevelText;
    CBasicTextBox*    m_pClubText;
    CBasicTextBox*    m_pDamageHighTextStatic;
    CBasicTextBox*    m_pDamageLowTextStatic;
    CBasicTextBox*    m_pDefenseTextStatic;
    CBasicTextBox*    m_pReqPaTextStatic;
    CBasicTextBox*    m_pReqSaTextStatic;    
    CBasicTextBox*    m_pReqMaTextStatic;    
    CBasicTextBox*    m_pHitRateTextStatic;
    CBasicTextBox*    m_pAvoidRateTextv;
    CBasicTextBox*    m_pHPTextStatic;
    CBasicTextBox*    m_pMPTextStatic;
    CBasicTextBox*    m_pSPTextStatic;

    CBasicTextBox*    m_pDamageHighText;
    CBasicTextBox*    m_pDamageLowText;
    CBasicTextBox*    m_pDefenseText;
    CBasicTextBox*    m_pReqPaText;
    CBasicTextBox*    m_pReqSaText;    
    CBasicTextBox*    m_pReqMaText;    
    CBasicTextBox*    m_pHitRateText;
    CBasicTextBox*    m_pAvoidRateText;
    CBasicTextBox*    m_pHPText;
    CBasicTextBox*    m_pMPText;
    CBasicTextBox*    m_pSPText;

    CBasicTextBox*    m_pDamageHighTextUp;
    CBasicTextBox*    m_pDamageLowTextUp;
    CBasicTextBox*    m_pDefenseTextUp;
    CBasicTextBox*    m_pReqPaTextUp;
    CBasicTextBox*    m_pReqSaTextUp;    
    CBasicTextBox*    m_pReqMaTextUp;    
    CBasicTextBox*    m_pHitRateTextUp;
    CBasicTextBox*    m_pAvoidRateTextUp;
    CBasicTextBox*    m_pHPTextUp;
    CBasicTextBox*    m_pMPTextUp;
    CBasicTextBox*    m_pSPTextUp;

private:    //    µéÒ¹·Ò¹
    CBasicTextBox*    m_pFireTextStatic;
    CBasicTextBox*    m_pColdTextStatic;
    CBasicTextBox*    m_pElectricTextStatic;
    CBasicTextBox*    m_pPoisonTextStatic;
    CBasicTextBox*    m_pSpiritTextStatic;

    CBasicTextBox*    m_pFireText;
    CBasicTextBox*    m_pColdText;
    CBasicTextBox*    m_pElectricText;
    CBasicTextBox*    m_pPoisonText;
    CBasicTextBox*    m_pSpiritText;

private:    //    ÊèǹµÑÇ
    CBasicTextBox*    m_pAcademy_Department;
    CBasicTextBox*    m_pActivityPointText;
    CBasicTextBox*    m_pActivityPointValue;
    CBasicTextBox*    m_pPKStateText;
    CBasicTextBox*    m_pDepartment;
    CUIControl*        m_pBrightFrame;
    CUIControl*        m_pBrightSlider;
    CBasicTextBox*    m_pGradeText;
    CBasicTextBox*    m_pGradeValue;
    CBasicTextBox*  m_pMobileText;

private: //Interface
    CUIControl*        m_bg_white;
    CBasicTextButton*    m_pPageButton[nMAXPAGENEW];

    CBasicLineBox*  m_pBackLine1;
    CBasicLineBox*  m_pBackLine2;

    CBasicLineBox*  m_pStatusLine1;
    CBasicLineBox*  m_pStatusLine2;
    CBasicLineBox*  m_pStatusLine3;
    CBasicLineBox*  m_pStatusLine4;
    CBasicLineBox*  m_pStatusLine5;
    CBasicLineBox*  m_pStatusLine6;
    CBasicLineBox*  m_pStatusLine7;
    CBasicLineBox*  m_pStatusLine8;
    CBasicLineBox*  m_pStatusLine9;

private:
CVehicleWindow*        m_pVehicleWindow;
CPetWindow*            m_pPetWindow;
CBasicTextButton*    CreateTextButton ( const char* szButton, UIGUID ControlID, const char* szText );

public:

void    SetArmSwapTabButton( BOOL bVisible );
void    SetVisiblePage ( int nPage );
CPetWindow*                GetPetWindow()                    { return m_pPetWindow; }

};

CharacterWindowEx.cpp

#include "StdAfx.h"
#include "CharacterWindow.h"

#include "../EngineUILib/GUInterface/BasicTextBox.h"
#include "../EngineUILib/GUInterface/BasicProgressBar.h"
#include "../EngineUILib/GUInterface/BasicButton.h"
#include "GLGaeaClient.h"
#include "UITextControl.h"
#include "GameTextControl.h"
#include "GLogicData.h"
#include "ItemSlot.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

void CCharacterWindow::SetLevel ( const GLCHARLOGIC& sCharData )
{
    const WORD& wLevel = sCharData.m_wLevel;
    const DWORD& wClub = sCharData.m_dwGuild;

    CString strCombine;
    strCombine.Format ( "Lv.%d ", wLevel );
    if ( m_pLevelText )
    {
        m_pLevelText->SetOneLineText ( strCombine + sCharData.m_szName, NS_UITEXTCOLOR::WHITE );
    }
    strCombine.Format ( "[%s]",wClub );
    if ( m_pClubText )
    {
        if(wClub == 0)
        {
            strCombine.Format ( "[%s]",ID2GAMEWORD("CLUB_TEXT_STATIC", 14) );
        }
        m_pClubText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::YELLOW );
    }
}

void CCharacterWindow::SetName ( const GLCHARLOGIC& sCharData )
{
    if ( m_pNameText )
    {
        m_pNameText->SetOneLineText ( sCharData.m_szName, NS_UITEXTCOLOR::ORANGE );
    }
}

void CCharacterWindow::SetBright ( const GLCHARLOGIC& sCharData )
{
    const int nMIN = -100;
    const int nMAX = 100;
    const int nRANGE = nMAX - nMIN;

    int nPercent = sCharData.GETBRIGHTPER ();
    nPercent = -(nPercent);    //    À̹ÌÁö°¡ ¹Ý´ë·Î µÚÁýÇôÀ־.
    if ( nPercent < nMIN ) nPercent = nMIN;
    if ( nPercent > nMAX ) nPercent = nMAX;

    nPercent += nMAX;

    float fPercent = static_cast<float>(nPercent) / static_cast<float>(nRANGE);

    const UIRECT& rcFramePos = m_pBrightFrame->GetGlobalPos ();
    const UIRECT& rcThumbPos = m_pBrightSlider->GetGlobalPos ();

    float fMOVE = (rcFramePos.sizeX - rcThumbPos.sizeX) * fPercent;
    float fLeft = rcFramePos.left + fMOVE;

    m_pBrightSlider->SetGlobalPos ( D3DXVECTOR2 ( fLeft, rcThumbPos.top ) );
}


void CCharacterWindow::SetGrade ( const GLCHARLOGIC& sCharData )
{
    if ( m_pGradeText && m_pGradeValue )
    {
        CString strCombine;
        strCombine.Format ( "%d", sCharData.m_nLiving );
        m_pGradeText->SetOneLineText ( ID2GAMEWORD("CHARACTER_SOCIAL_STATIC",7), NS_UITEXTCOLOR::SILVER );
        m_pGradeValue->SetOneLineText ( strCombine , NS_UITEXTCOLOR::SILVER);
    }
}

void CCharacterWindow::SetActivityPoint ( const GLCHARLOGIC& sCharData )
{
    if ( m_pActivityPointText && m_pActivityPointValue)
    {
        CString strCombine;
        strCombine.Format ( "%d", sCharData.m_nLiving );
        m_pActivityPointText->SetOneLineText ( ID2GAMEWORD("CHARACTER_SOCIAL_STATIC",2), NS_UITEXTCOLOR::SILVER );
        m_pActivityPointValue->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
    }
}

void CCharacterWindow::SetAcademy_Department ( const GLCHARLOGIC& sCharData )
{
    if ( m_pAcademy_Department )
    {
        CString strCombine;
        strCombine.Format ( "%s,%s", ID2GAMEWORD("ACADEMY_NAME",sCharData.m_wSchool), COMMENT::CHARCLASS[CharClassToIndex(sCharData.m_emClass)].c_str() );
        m_pAcademy_Department->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
    }
}

void CCharacterWindow::SetPoint ( const GLCHARLOGIC& sCharData )
{
    if ( sCharData.m_wStatsPoint < 0)    return;
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_wStatsPoint );
    if ( m_pPointText ) m_pPointText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::GOLD );

}
//    Stat    
void CCharacterWindow::SetPow ( const GLCHARLOGIC& sCharData )
{
    m_pPowText->ClearText ();

    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMSTATS.wPow );
    m_pPowText->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
    
}

void CCharacterWindow::SetDex ( const GLCHARLOGIC& sCharData )
{
    m_pDexText->ClearText ();

    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMSTATS.wDex );
    m_pDexText->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetSpi ( const GLCHARLOGIC& sCharData )
{
    m_pSpiText->ClearText ();

    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMSTATS.wSpi );
    m_pSpiText->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );

}

void CCharacterWindow::SetStr ( const GLCHARLOGIC& sCharData )
{
    m_pStrText->ClearText ();

    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMSTATS.wStr ); 
    m_pStrText->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetSta ( const GLCHARLOGIC& sCharData )
{
    m_pStaText->ClearText ();

    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMSTATS.wSta ); 
    m_pStaText->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );

}


void CCharacterWindow::SetPowUp ( int num,const GLCHARLOGIC& sCharData )
{
    m_pPowTextUp->ClearText ();
    CString strCombine;
    strCombine.Format ( "(%d)", sCharData.m_sSUMSTATS.wPow + num );
    m_pPowTextUp->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
}
void CCharacterWindow::SetDexUp ( int num,const GLCHARLOGIC& sCharData )
{
    m_pDexTextUp->ClearText ();
    CString strCombine;
    strCombine.Format ( "(%d)", sCharData.m_sSUMSTATS.wDex + num );
    m_pDexTextUp->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
}
void CCharacterWindow::SetSpiUp ( int num,const GLCHARLOGIC& sCharData )
{
    m_pSpiTextUp->ClearText ();
    CString strCombine;
    strCombine.Format ( "(%d)", sCharData.m_sSUMSTATS.wSpi + num );
    m_pSpiTextUp->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
}
void CCharacterWindow::SetStrUp ( int num,const GLCHARLOGIC& sCharData )
{
    m_pStrTextUp->ClearText ();
    CString strCombine;
    strCombine.Format ( "(%d)", sCharData.m_sSUMSTATS.wStr + num );
    m_pStrTextUp->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
}
void CCharacterWindow::SetStaUp ( int num,const GLCHARLOGIC& sCharData )
{
    m_pStaTextUp->ClearText ();
    CString strCombine;
    strCombine.Format ( "(%d)", sCharData.m_sSUMSTATS.wSta + num );
    m_pStaTextUp->AddText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

//    Status
void CCharacterWindow::SetDamage ( const GLCHARLOGIC& sCharData )
{    
    const int& nLow = sCharData.GETFORCE_LOW ();
    const int& nHigh = sCharData.GETFORCE_HIGH ();

    CString strCombine;
    strCombine.Format ( "%d", nLow );
    if ( m_pDamageLowText ) m_pDamageLowText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );

    strCombine.Format ( "%d", nHigh );
    if ( m_pDamageHighText ) m_pDamageHighText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetDefense ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.GETDEFENSE () );
    if ( m_pDefenseText ) m_pDefenseText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetReqPa ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_wSUM_PA );
    if ( m_pReqPaText ) m_pReqPaText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetReqSa ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_wSUM_SA );
    if ( m_pReqSaText ) m_pReqSaText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetReqMa ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_wSUM_MA );
    if ( m_pReqMaText ) m_pReqMaText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetHitRate ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.GETHIT () );
    if ( m_pHitRateText ) m_pHitRateText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetHP ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.GETMAXHP () );
    if ( m_pHPText ) m_pHPText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetMP ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sMP.wHigh );
    if ( m_pMPText ) m_pMPText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetSP ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSP.wHigh );
    if ( m_pSPText ) m_pSPText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetAvoidRate ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.GETAVOID () );
    if ( m_pAvoidRateText ) m_pAvoidRateText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetFireResi ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMRESIST_SKILL.nFire );
    if ( m_pFireText ) m_pFireText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetColdResi ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMRESIST_SKILL.nIce );
    if ( m_pColdText ) m_pColdText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetElectricResi ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMRESIST_SKILL.nElectric );
    if ( m_pElectricText ) m_pElectricText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetPoisonResi ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMRESIST_SKILL.nPoison );
    if ( m_pPoisonText ) m_pPoisonText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

void CCharacterWindow::SetSpiritResi ( const GLCHARLOGIC& sCharData )
{
    CString strCombine;
    strCombine.Format ( "%d", sCharData.m_sSUMRESIST_SKILL.nSpirit );
    if ( m_pSpiritText ) m_pSpiritText->SetOneLineText ( strCombine, NS_UITEXTCOLOR::SILVER );
}

CharacterWindowMsg.cpp

#include "StdAfx.h"
#include "./CharacterWindow.h"

#include "../G-Logic/GLGaeaClient.h"

#include "../EngineUILib/GUInterface/BasicTextBox.h"
#include "../EngineUILib/GUInterface/BasicButton.h"

#include "../Interface/ModalCallerID.h"
#include "../Interface/ModalWindow.h"
#include "../Interface/InnerInterface.h"
#include "../Interface/UITextControl.h"
#include "../Interface/GameTextControl.h"
#include "InventoryPageWear.h"
#include "InventoryPageWearEx.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

void CCharacterWindow::TranslateUIMessage ( UIGUID ControlID, DWORD dwMsg )
{
    CUIWindowEx::TranslateUIMessage ( ControlID, dwMsg );

    const GLCHARLOGIC& sCharData = GLGaeaClient::GetInstance().GetCharacterLogic ();

    const float fBUTTON_CLICK = CBasicButton::fBUTTON_CLICK;

    switch ( ControlID )
    {
    case ET_CONTROL_TITLE:
    case ET_CONTROL_TITLE_F:
        {
            if ( (dwMsg & UIMSG_LB_DUP) && CHECK_MOUSE_IN ( dwMsg ) )
            {
                CInnerInterface::GetInstance().SetDefaultPosInterface( CHARACTER_WINDOW );
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_POW_PLUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( sCharData.m_wStatsPoint > 0 )
                    {
                        m_pNewPow++;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointDown();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_DEX_PLUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( sCharData.m_wStatsPoint > 0)
                    {
                        m_pNewDex++;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointDown();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_SPI_PLUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( sCharData.m_wStatsPoint > 0)
                    {
                        m_pNewSpi++;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointDown();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_STR_PLUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( sCharData.m_wStatsPoint > 0 )
                    {
                        m_pNewStr++;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointDown();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_STA_PLUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( sCharData.m_wStatsPoint > 0)
                    {
                        m_pNewSta++;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointDown();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_POW_MINUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( m_pNewPow > 0)
                    {
                        m_pNewPow--;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointUp();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_DEX_MINUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( m_pNewDex > 0)
                    {
                        m_pNewDex--;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointUp();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_SPI_MINUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( m_pNewSpi > 0)
                    {
                        m_pNewSpi--;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointUp();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_STR_MINUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( m_pNewStr > 0)
                    {
                        m_pNewStr--;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointUp();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_STA_MINUS_BUTTON:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    if ( m_pNewSta > 0)
                    {
                        m_pNewSta--;
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointUp();
                    }
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_OK:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_DOWN_LIKE ( dwMsg ) )
                {
                }

                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {    
                    int num = m_pNewPow + m_pNewDex + m_pNewSpi + m_pNewStr + m_pNewSta;
                    for (int i = 0; i < num; i++)
                    {
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointUp();
                    }
                    if ( m_pNewPow > 0)
                    {
                        for ( int i = 0; i < m_pNewPow; i++)
                        {
                            GLGaeaClient::GetInstance().GetCharacter()->ReqStatsUp ( EMPOW );
                        }
                    }
                    if ( m_pNewDex > 0)
                    {
                        for ( int i = 0; i < m_pNewDex; i++)
                        {
                            GLGaeaClient::GetInstance().GetCharacter()->ReqStatsUp ( EMDEX );
                        }
                    }
                    if ( m_pNewSpi > 0)
                    {
                        for ( int i = 0; i < m_pNewSpi; i++)
                        {
                            GLGaeaClient::GetInstance().GetCharacter()->ReqStatsUp ( EMSPI );
                        }
                    }
                    if ( m_pNewStr > 0)
                    {
                        for ( int i = 0; i < m_pNewStr; i++)
                        {
                            GLGaeaClient::GetInstance().GetCharacter()->ReqStatsUp ( EMSTR );
                        }
                    }
                    if ( m_pNewSta > 0)
                    {
                        for ( int i = 0; i < m_pNewSta; i++)
                        {
                            GLGaeaClient::GetInstance().GetCharacter()->ReqStatsUp ( EMSTA );
                        }
                    }
                    m_pNewPow = 0;
                    m_pNewDex = 0;
                    m_pNewSpi = 0;
                    m_pNewStr = 0;
                    m_pNewSta = 0;
                }
            }
        }
        break;
    case CHARACTER_WINDOW_STAT_CANCEL:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                if ( CHECK_LB_UP_LIKE ( dwMsg ) )
                {                    
                    int num = m_pNewPow + m_pNewDex + m_pNewSpi + m_pNewStr + m_pNewSta;
                    for (int i = 0; i < num; i++)
                    {
                        GLGaeaClient::GetInstance().GetCharacter()->SetStatusPointUp();
                    }
                    m_pNewPow = 0;
                    m_pNewDex = 0;
                    m_pNewSpi = 0;
                    m_pNewStr = 0;
                    m_pNewSta = 0;
                }

            }
        }
        break;
    case CHARACTER_BIRGHTER:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                GLCharacter* pCharacter = GLGaeaClient::GetInstance().GetCharacter ();

                CString strTemp;                
                strTemp.Format ( "%d", pCharacter->m_nBright );

                CInnerInterface::GetInstance().SHOW_COMMON_LINEINFO ( strTemp, NS_UITEXTCOLOR::WHITE );
            }
        }
        break;
    case CHARACTER_WINDOW_INVENTORY_PAGEWEAR:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                int nIndex = m_pPageWear->GetItemIndex ();
                if ( nIndex < 0 ) return ;                

                {
                    SITEMCUSTOM sItemCustom = m_pPageWear->GetItem ( nIndex );
                    if ( sItemCustom.sNativeID != NATIVEID_NULL () )
                    {
                        CInnerInterface::GetInstance().SHOW_ITEM_INFO ( sItemCustom, FALSE, FALSE, FALSE, USHRT_MAX, USHRT_MAX );
                    }
                }

                if ( dwMsg & UIMSG_LB_UP )
                {
                    EMSLOT emSlot = m_pPageWear->GetItemSlot ();
                    GLGaeaClient::GetInstance().GetCharacter()->ReqSlotTo ( emSlot );
                }        
            }
        }
        break;
    case CHARACTER_WINDOW_INVENTORY_PAGEWEAR_EX:
        {
            if ( CHECK_MOUSE_IN ( dwMsg ) )
            {
                int nIndex = m_pPageWearEx->GetItemIndex ();
                if ( nIndex < 0 ) return ;                

                {
                    SITEMCUSTOM sItemCustom = m_pPageWearEx->GetItem ( nIndex );
                    if ( sItemCustom.sNativeID != NATIVEID_NULL () )
                    {
                        CInnerInterface::GetInstance().SHOW_ITEM_INFO ( sItemCustom, FALSE, FALSE, FALSE, USHRT_MAX, USHRT_MAX );
                    }
                }

                if ( dwMsg & UIMSG_LB_UP )
                {
                    EMSLOT emSlot = m_pPageWearEx->GetItemSlot ();
                    GLGaeaClient::GetInstance().GetCharacter()->ReqSlotTo ( emSlot );
                }
            }
        }
        break;

        case RNCHARACTER_WINDOW_CHAR_TAP: 
            {
                if ( CHECK_MOUSEIN_LBUPLIKE ( dwMsg ) )
                    {
                        SetVisiblePage (0);
                    }
            }
        break;

        case RNCHARACTER_WINDOW_VEHICLE_TAP: 
            {
                if ( CHECK_MOUSEIN_LBUPLIKE ( dwMsg ) )
                {
                    SetVisiblePage (1);
                }
            }
        break;

        case RNCHARACTER_WINDOW_PET_TAP: 
            {
                if ( CHECK_MOUSEIN_LBUPLIKE ( dwMsg ) )
                {
                    SetVisiblePage (2);
                }
            }
        break;
    }
}

CharacterWindowUpdate.cpp

#include "StdAfx.h"
#include "CharacterWindow.h"
#include "GLGaeaClient.h"
#include "../EngineUILib/GUInterface/BasicButton.h"
#include "../EngineUILib/GUInterface/BasicTextBox.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

void CCharacterWindow::Update ( int x, int y, BYTE LB, BYTE MB, BYTE RB, int nScroll, float fElapsedTime, BOOL bFirstControl )
{    
    const GLCHARLOGIC& sCharData = GLGaeaClient::GetInstance().GetCharacterLogic ();    
    BOOL bPointUsable = (sCharData.m_wStatsPoint)?TRUE:FALSE;

//    ½ºÅÈ ÄÁÆ®·Ñ
    //SetPointControl ( bPointUsable );

//    À̸§,Ŭ·¡½º    
    SetName ( sCharData );

//    °æÇèÄ¡
//    SetEXP ( sCharData );

//    Stat    
    SetPow ( sCharData );
    SetDex ( sCharData );
    SetSpi ( sCharData );
    SetStr ( sCharData );
    SetSta ( sCharData );

    SetPowUp ( m_pNewPow,sCharData );
    SetDexUp ( m_pNewDex,sCharData );
    SetSpiUp ( m_pNewSpi,sCharData );
    SetStrUp ( m_pNewStr,sCharData );
    SetStaUp ( m_pNewSta,sCharData );
    SetPoint ( sCharData );
//
////    Status
    SetLevel ( sCharData );
    SetDamage ( sCharData );
    SetDefense ( sCharData );
    SetReqPa ( sCharData );
    SetReqSa ( sCharData );    
    SetReqMa ( sCharData );    
    SetHP ( sCharData );
    SetMP ( sCharData );
    SetSP ( sCharData );
    SetHitRate ( sCharData );
    SetAvoidRate ( sCharData );

    SetFireResi ( sCharData );
    SetColdResi ( sCharData );
    SetElectricResi ( sCharData );
    SetPoisonResi ( sCharData );
    SetSpiritResi ( sCharData );

    SetAcademy_Department ( sCharData );
    SetActivityPoint ( sCharData );
    SetBright ( sCharData );
    SetGrade ( sCharData );

    CUIWindow::Update ( x, y, LB, MB, RB, nScroll, fElapsedTime, bFirstControl );


}

void CCharacterWindow::SetVisibleSingle ( BOOL bVisible )
{
    CUIWindow::SetVisibleSingle( bVisible );

    if( bVisible )
    {
        const GLCHARLOGIC& sCharData = GLGaeaClient::GetInstance().GetCharacterLogic ();
        //SetPhoneNumber( sCharData.m_szPhoneNumber );
    }
}

GLCharacter.h

public:
    HRESULT SetPosition ( D3DXVECTOR3 vPos );
    virtual const D3DXVECTOR3 &GetPosition ()    { return m_vPos; }
    float GetDirection ();
    D3DXVECTOR3 GetDirectionVector () { return m_vDir; }
        D3DXVECTOR3 GetOrig()    { return m_vDirOrig; }
    D3DXMATRIX    GetMatrix()    { return m_matTrans; }

NOTE : I DONT KNOW IF THIS IS COMPATIBLE WITH NEO SOURCE OR NOT..T.A.E (NOT TESTED)

here is the results

[kopral105]

here is the results

is that cool man .. can you share that ? i dont have VS 2003 can't download always error in instalation

[CharlesCode]

feel so sad , this code not working in neo source :'( fatal error for server files only Reditor and bugtral.dll are show up after compiling..

Merge it,
dont just copy paste the code.

[ultrrain]

im not copy paste i just try to add some code functions of sir asendure to my missing code of my source

[tapx5505]

Merge it,
dont just copy paste the code.

i only copy pasted and it worked fine :P

[JerMTheSLayer]

this is the prob when someone is sharing ppl dont want to explore and use trial and error , and don't canll someone SELFISH cause he/she didn't share something dont spoon feed use ur eyes bunch of source code already shared in rz why not explore.

[sexual123]

this is the prob when someone is sharing ppl dont want to explore and use trial and error , and don't canll someone SELFISH cause he/she didn't share something dont spoon feed use ur eyes bunch of source code already shared in rz why not explore.

i second emotion :)

[petercrow]

im using Ran World New Client client and bin by ramposi but when i using Emulator have error, please tell me how to fix this, thank all

[tapx5505]

^ increase your RAM :3

[petercrow]

^ increase your RAM :3

using wn7 64 with 4gb ram. im have using so many Emulator normal, but this source have error

[JerMTheSLayer]

Gui problem at 2 weapon slots
1.correct gui but wrong item slot

correct gui

wrong input


this is the screenshot in asendure's code



so i Fixed it

correct gui


correct item slot



How to fix?
Answer: i change something in source affecting the charwindow and 2weap slots and gui(.xml) goodluck

[xhellin]

Gui problem at 2 weapon slots
1.correct gui but wrong item slot

correct gui

wrong input


this is the screenshot in asendure's code



so i Fixed it

correct gui


correct item slot



How to fix?
Answer: i change something in source affecting the charwindow and 2weap slots and gui(.xml) goodluck

mine is really working :D jk .. btw check my message in FB.

[Eil Nahd]

Gui problem at 2 weapon slots
1.correct gui but wrong item slot

correct gui

wrong input


this is the screenshot in asendure's code



so i Fixed it

correct gui


correct item slot



How to fix?
Answer: i change something in source affecting the charwindow and 2weap slots and gui(.xml) goodluck

im sure ur not selfish right? can u sahre fix gui :) im begging u :P please :)

[tapx5505]

yeah share it hahaha lol :)