Neo Source

wrongteousOne said:
Anyone here successfully open crow mnsf using mobnpc editor?

item isf/skill` works fine but failed in crow mnsf.

i`ve tried to decypt it` succeed accordingly but it seems that file remain encrypted..

Any advice guys..
Click to expand...

how did you open your skill and item editor??

@fusion

can you share me your texture/gui with dual weapon slot and pet and vehicle
 
Last edited:
@jayanna1421 just dec your item.isf , ItemStrTable.txt and comment.ini and put besides 1logic.rcc and for skill just dec your skill.ssf , SkillStrTable.txt
raffy0809 - Neo Source - RaGEZONE Forums
 
how to fix skill name i change name of skill.isf in my skilleditor i already decrypt it then i use my emulator still loading-loading-loading only?
 
tapx5505 said:
@Asendure i got error :(

VGA9GRK - Neo Source - RaGEZONE Forums
Click to expand...

GLCharacter.h
Code: 
public:
	HRESULT SetPosition ( D3DXVECTOR3 vPos );
	virtual const D3DXVECTOR3 &GetPosition ()	{ return m_vPos; }
	float GetDirection ();
	D3DXVECTOR3 GetDirectionVector () { return m_vDir; }
[COLOR="#FF0000"]	D3DXVECTOR3 GetOrig()	{ return m_vDirOrig; }
	D3DXMATRIX	GetMatrix()	{ return m_matTrans; }[/COLOR]
 
AsenDURE said:
GLCharacter.h
Code: 
public:
    HRESULT SetPosition ( D3DXVECTOR3 vPos );
    virtual const D3DXVECTOR3 &GetPosition ()    { return m_vPos; }
    float GetDirection ();
    D3DXVECTOR3 GetDirectionVector () { return m_vDir; }
[COLOR=#FF0000]    D3DXVECTOR3 GetOrig()    { return m_vDirOrig; }
    D3DXMATRIX    GetMatrix()    { return m_matTrans; }[/COLOR]
Click to expand...

@asenDURE
sire can you help me^_^ if that oki with you because i cant download the VS2003 And i cant compile the source you share maybe you can share me the compiled already plsss
 
jayanna1421 said:
@asenDURE
sire can you help me^_^ if that oki with you because i cant download the VS2003 And i cant compile the source you share maybe you can share me the compiled already plsss
Click to expand...

Here is the VS2003 PRO DL LINK :)

To view the content, you need to sign in or register
 
AsenDURE said:
CHARACTER / VEHICLE / PET + DUAL SLOT WEAPON

CharacterWindow.cpp
Code: 
#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
Code: 
#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
Code: 
#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
Code: 
#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
Code: 
#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
Code: 
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)
Click to expand...


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..
 
ultrrain said:
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..
Click to expand...
it's working on me, using this source :) (IM USING NEO SOURCE)

========================================
BTW,

@Asendure can you please share fix gui for Vehicle and Pet Window ? :)

SS:
x0hKeij - Neo Source - RaGEZONE Forums
 
tapx5505 said:
it's working on me, using this source :) (IM USING NEO SOURCE)

========================================
BTW,

@Asendure can you please share fix gui for Vehicle and Pet Window ? :)

SS:
x0hKeij - Neo Source - RaGEZONE Forums
Click to expand...

CANNOT.

why ? because its only about gui..its not hard, you're too lazy to fix that simple. btw, im lazy to upload it

take your time..learn not to always depends to others.
 
You must log in or register to reply here.

RaGEZONE Sponsor

    HyperFilter

About RaGEZONE

RaGEZONE® is a leading MMO and MMORPG development community offering source codes, server files, tutorials, tools, and private servers for developers and gamers.

Forum Statistics

Members online
2,610
Guests online
12,504
Total visitors
15,114
Totals may include hidden visitors.

RaGEZONE Partners

    non GamStop casinos
Back