#pragma once

#include "stdafx.h"
#include <windows.h>

#ifndef _RAPPELZ_CONFIG
#include "KRenderDeviceDX.h"
#endif

#include "SGameOption.h"

//#include "Util.h"
#include <toolkit/XEnv.h>
#include <dump/XException.h>

#ifdef _RAC
	#include "SStringDB.h"
#endif


#include <kfile/KFileManager.h>
#include "SLog.h"

#include <map>

namespace
{
	enum INTERFACE
	{
		INTERFACE_SMALL = 0,
		INTERFACE_NORMAL,
		INTERFACE_LARGE,
	};

	enum MINIMAP
	{
		MINIMAP_ALPHA_MIN = 0,
		MINIMAP_ALPHA_MIDDLE,
		MINIMAP_ALPHA_MAX,
	};

	enum CHAT_TYPE
	{
		CHAT_ALL = 0,
		CHAT_WHISPER,
		CHAT_PARTY,
		CHAT_GUILD,
		CHAT_AD,
		CHAT_NOTICE,
		CHAT_SYSTEM,
	};
};

#define ERR_RESULT	-1

bool g_bDefSet[SGAME_OPT_DATA::c_nMaxChannel][SGAME_OPT_DATA::c_nMaxChatOption] =
{
	//사용자, 일반, 광역, 광고, 귓속, 친한 귓속,   | 그룹, 파티, 길드, 공대, |  시스템, 경험치, NPC, 기본데미지, 스킬데미지,아이템, 전투 ,크리처, 기타
	{ true , true , true, true , true , true ,		true , true, true , true ,	true , true , true , true    , true      , true , true , true , true , },
	{ true , true , true, true , true , true ,		true , true, true , true ,	true , true, false, true     , true      , true , false, false, true , },
	{ true , false, false, false, true, true ,		true , true, true ,	false,	false, false, false, false   , false     , false, false, false, false, },
	{ true , false, false, false, true, true,		true, false, true , true ,	false, false, false, false   , false     , false, false, false, false, },
	{ true , false, true, true , false, false,		false, false, false, false,	false, false, false, false   , false     , false, false, false, false, },
};

SGameOption::SGameOption()
: m_nQuickVerX(-1), m_nQuickVerY(-1), m_nQuickHozX(-1), m_nQuickHozY(-1), m_nVerticalQuick(-1), m_nStateVerX(-1), m_nStateVerY(-1),
  m_nStateHozX(-1), m_nStateHozY(-1), m_nVerticalState(-1), m_nMessangerX(-1), m_nMessangerY(-1), m_nMessangerOpen(-1), m_nCreatureOpen(-1),
  m_nSysMenuX(-1), m_nSysMenuY(-1), m_nInventoryX(-1), m_nInventoryY(-1), m_nChattingLine(-1), m_nChattingHeight(-1),
  m_nCreatureX(-1), m_nCreatureY(-1), m_nCreatureInfoX(-1), m_nCreatureInfoY(-1), m_nQuestX(-1), m_nQuestY(-1),
  m_nMotionX(-1), m_nMotionY(-1), m_nOptionX(-1), m_nOptionY(-1), m_nCharX(-1), m_nCharY(-1), m_nSkillX(-1), m_nSkillY(-1),
  m_nSystemX(-1), m_nSystemY(-1), m_nMapX(-1), m_nMapY(-1), m_nItemCombineX(-1), m_nItemCombineY(-1), m_nShopX(-1), m_nShopY(-1),
  m_nStoreX(-1), m_nStoreY(-1), m_nStorageX(-1), m_nStorageY(-1),
  m_nCreatureSkillX(-1), m_nCreatureSkillY(-1), m_nPosEquipment( -1, -1 )
  , m_bOpenEquipWnd(false) //servantes 2010.11.02
{
	SetEnvironmenteDefault(m_defData);
	SetPlayDataDefault(m_defData);
	Init();

	m_MemSize = 0;

	int i,j;
	for( j = 0; j < SGAME_OPT_DATA::c_nMaxChannel; j++ )
	{
		for( i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )	
			m_bChannelCheck[j][i] = g_bDefSet[j][i];
	}

	m_bChatOpen = true;

	/// 2011.02.16 - prodongi
	m_useRechargeMsgBox = 1;
}

SGameOption::~SGameOption()
{
	Destroy();
}

void SGameOption::InitChattinSet()
{
#ifdef _RAC
	m_strTabName[0] = S(6369);//"전체";
	m_strTabName[1] = S(6370);//"일반";
	m_strTabName[2] = S(6371);//"파티";
	m_strTabName[3] = S(6372);//"길드";
	m_strTabName[4] = S(6373);//"광고";
#else
	m_strTabName[0] = "";
	m_strTabName[1] = "";
	m_strTabName[2] = "";
	m_strTabName[3] = "";
	m_strTabName[4] = "";
#endif

	m_strTabMark[0] = "";
	m_strTabMark[1] = "";
	m_strTabMark[2] = "#";
	m_strTabMark[3] = "%";
	m_strTabMark[4] = "$";
}

bool SGameOption::GetPresetOptData( int level, _OPT_DATA& data )
{
	if ( level <= 0 || level > PRESET_HIGHEST )
		return false;

	data.nMASTER_Volume		= m_curData.nMASTER_Volume;
	data.nAllMute			= m_curData.nAllMute;
	data.nSFX_Volume		= m_curData.nSFX_Volume;
	data.nSFX_Mute			= m_curData.nSFX_Mute;
	data.nENVS_Volume		= m_curData.nENVS_Volume;
	data.nENVS_Mute			= m_curData.nENVS_Mute;
	data.nBGM_Volume		= m_curData.nBGM_Volume;
	data.nBGM_Mute			= m_curData.nBGM_Mute;

	switch ( level )
	{
	case PRESET_LOWEST:

		//최저 사양 옵션
		data.nResolution_Width  = 1024;  //해상도 가로
		data.nResolution_Height = 768;   //해상도 세로
		data.nRefreshRate		= 1;
		
		data.nBackGrondDis		= 0;//0~4
		data.nTerrainDis		= 0;//0~4
		data.nPropDis			= 0;//0~3
		data.nSpeedDis			= 0;//0~3
		data.nGrassDis			= 0;//0~3
		data.nAvatarDis			= 0;//0~3
		data.nShadowDis			= 0;
		data.nLowShadow			= 1;

		data.nSpeedQual			= 0;//0~3
		data.nMipBias			= 0;//0~2
		data.nSelfShadowQual	= 0;//0~3
		data.nGlowQual			= 0;//0~1

		data.nWaterQual			= 0;
		data.nResourceQual		= 0;
		data.nTownLimit			= 1;
		data.nEnhance			= 0;
		data.nShadow			= 0;
		data.nStateEffect			= 0;
		data.nStateEffectPlayer		= 0;
		data.nStateEffectParty		= 0;
		data.nStateEffectEnemy		= 0;

		data.nRenderTree		= 0;
		data.nRenderGrass		= 0;

		data.nEffect			= 0;
		data.nEffectPlayer		= 0;
		data.nEffectParty		= 0;
		data.nEffectEnemy		= 0;

		data.nFaceAni           = 0;

		data.nLightMap			= 0;
		break;

	case PRESET_LOW:

		//저사양 옵션
		data.nResolution_Width  = 1024;  //해상도 가로
		data.nResolution_Height = 768;   //해상도 세로
		data.nRefreshRate		= 1;
		
		data.nBackGrondDis		= 1;//0~4
		data.nTerrainDis		= 1;//0~4
		data.nPropDis			= 1;//0~3
		data.nSpeedDis			= 2;//0~3
		data.nGrassDis			= 1;//0~3
		data.nAvatarDis			= 0;//0~3
		data.nShadowDis			= 0;
		data.nLowShadow			= 1;

		data.nSpeedQual			= 2;//0~3
		data.nMipBias			= 0;//0~2
		data.nSelfShadowQual	= 0;//0~3
		data.nGlowQual			= 0;//0~1

		data.nWaterQual			= 0;
		data.nResourceQual		= 0;
		data.nTownLimit			= 1;
		data.nEnhance			= 0;
		data.nShadow			= 1;
		data.nStateEffect			= 1;
		data.nStateEffectPlayer		= 1;
		data.nStateEffectParty		= 0;
		data.nStateEffectEnemy		= 0;

		data.nRenderTree		= 0;
		data.nRenderGrass		= 0;

		data.nEffect			= 0;
		data.nEffectPlayer		= 0;
		data.nEffectParty		= 0;
		data.nEffectEnemy		= 0;

		data.nFaceAni           = 0;

		data.nLightMap			= 0;
		break;

	case PRESET_MID:

		//중사양 옵션
		data.nResolution_Width  = 1024;  //해상도 가로
		data.nResolution_Height = 768;   //해상도 세로
		data.nRefreshRate		= 1;
		
		data.nBackGrondDis		= 2;//0~4
		data.nTerrainDis		= 2;//0~4
		data.nPropDis			= 2;//0~3
		data.nSpeedDis			= 3;//0~3
		data.nGrassDis			= 2;//0~3
		data.nAvatarDis			= 1;//0~3
		data.nShadowDis			= 0;
		data.nLowShadow			= 0;

		data.nSpeedQual			= 2;//0~3
		data.nMipBias			= 1;//0~2
		data.nSelfShadowQual	= 0;//0~3
		data.nGlowQual			= 0;//0~1

		data.nWaterQual			= 1;
		data.nResourceQual		= 1;
		data.nTownLimit			= 0;
		data.nEnhance			= 1;
		data.nShadow			= 1;
		data.nStateEffect			= 1;
		data.nStateEffectPlayer		= 1;
		data.nStateEffectParty		= 1;
		data.nStateEffectEnemy		= 0;

		data.nRenderTree		= 1;
		data.nRenderGrass		= 1;

		data.nEffect			= 1;
		data.nEffectPlayer		= 1;
		data.nEffectParty		= 0;
		data.nEffectEnemy		= 0;

		data.nFaceAni           = 1;

		data.nLightMap			= 0;
		break;

	case PRESET_HIGH:

		//고사양 옵션
		data.nResolution_Width  = 1024;  //해상도 가로
		data.nResolution_Height = 768;   //해상도 세로
		data.nRefreshRate		= 1;
		
		data.nBackGrondDis		= 3;//0~4
		data.nTerrainDis		= 3;//0~4
		data.nPropDis			= 3;//0~3
		data.nSpeedDis			= 3;//0~3
		data.nGrassDis			= 3;//0~3
		data.nAvatarDis			= 2;//0~3
		data.nShadowDis			= 1;
		data.nLowShadow			= 0;

		data.nSpeedQual			= 3;//0~3
		data.nMipBias			= 2;//0~2
		data.nSelfShadowQual	= 1;//0~3
		data.nGlowQual			= 0;//0~1

		data.nWaterQual			= 1;
		data.nResourceQual		= 1;
		data.nTownLimit			= 0;
		data.nEnhance			= 1;
		data.nShadow			= 1;
		data.nStateEffect			= 1;
		data.nStateEffectPlayer		= 1;
		data.nStateEffectParty		= 1;
		data.nStateEffectEnemy		= 0;

		data.nRenderTree		= 1;
		data.nRenderGrass		= 1;

		data.nEffect			= 1;
		data.nEffectPlayer		= 1;
		data.nEffectParty		= 1;
		data.nEffectEnemy		= 0;

		data.nFaceAni           = 2;

		data.nLightMap			= 0;
		break;

	case PRESET_HIGHEST:

		//최고사양 옵션
		data.nResolution_Width  = 1024;  //해상도 가로
		data.nResolution_Height = 768;   //해상도 세로
		data.nRefreshRate		= 1;
		
		data.nBackGrondDis		= 4;//0~4
		data.nTerrainDis		= 4;//0~4
		data.nPropDis			= 3;//0~3
		data.nSpeedDis			= 3;//0~3
		data.nGrassDis			= 3;//0~3
		data.nAvatarDis			= 3;//0~3
		data.nShadowDis			= 1;
		data.nLowShadow			= 0;

		data.nSpeedQual			= 3;//0~3
		data.nMipBias			= 2;//0~2
		data.nSelfShadowQual	= 3;//0~3
		data.nGlowQual			= 1;//0~1

		data.nWaterQual			= 1;
		data.nResourceQual		= 1;
		data.nTownLimit			= 0;
		data.nEnhance			= 1;
		data.nShadow			= 1;
		data.nStateEffect			= 1;
		data.nStateEffectPlayer		= 1;
		data.nStateEffectParty		= 1;
		data.nStateEffectEnemy		= 1;

		data.nRenderTree		= 1;
		data.nRenderGrass		= 1;

		data.nEffect			= 1;
		data.nEffectPlayer		= 1;
		data.nEffectParty		= 1;
		data.nEffectEnemy		= 1;

		data.nFaceAni           = 2;
		data.nLightMap			= 1;
		break;

	default:
		return false;
	}

	//저사양 클라이언트 버전이여도 지형 표시 거리와 캐릭터 표시 거리는 수정 가능하다
	if( ENV().IsExist( "minimum_system" ) )
	{
		data.nTerrainDis		= m_curData.nTerrainDis;
		data.nAvatarDis			= m_curData.nAvatarDis;
	}

	return true;
}

int SGameOption::GetResolution_Index( int nWidth, int nHeight )
{
	for( UINT i(0); m_distMode.size()>i; i++ )
	{
		if( m_distMode[i].width  == nWidth && 
			m_distMode[i].height == nHeight )
		{
			return i;
		}
	}

	return 0;
}

void SGameOption::AddDispMode( 	UINT width, UINT height, UINT refreshrate )
{
	for( UINT i(0); m_distMode.size()>i; i++ )
	{
		if( m_distMode[i].width  == width && 
			m_distMode[i].height == height )
		{
			m_distMode[i].refreshrate_list.push_back( refreshrate );
			return;
		}
	}

	DISP_MODE dp_mode;
	dp_mode.width       = width;
	dp_mode.height      = height;
	dp_mode.refreshrate_list.push_back( refreshrate );
	m_distMode.push_back( dp_mode );
}

void SGameOption::SetOptionData( int nMode )
{
	switch(nMode)
	{
	case SGAME_OPT_DATA::MODE_ENVIRONMENT:
		{
			m_OptionManager.SetValueInt( "GRAPHIC_RESOLUTION_WIDTH"	, m_curData.nResolution_Width , true );   //해상도 가로
			m_OptionManager.SetValueInt( "GRAPHIC_RESOLUTION_HEIGHT", m_curData.nResolution_Height, true );   //해상도 세로

			m_OptionManager.SetValueInt( "GRAPHIC_REFRESHRATE"		, m_curData.nRefreshRate	, true );   //화면 재생 빈도
			m_OptionManager.SetValueInt( "GRAPHIC_WINMODE"			, m_curData.nWinMode		, true );   //Full, Window
			m_OptionManager.SetValueInt( "GRAPHIC_FULLWINMODE"		, m_curData.nFullWinMode	, true );   //전체창

			m_OptionManager.SetValueInt( "GRAPHIC_BACKGROUNDDIS"	, m_curData.nBackGrondDis	, true );   //배경   표시거리
			m_OptionManager.SetValueInt( "GRAPHIC_TERRAINDIS"		, m_curData.nTerrainDis		, true );   //지면   표시거리
			m_OptionManager.SetValueInt( "GRAPHIC_PROPDIS"			, m_curData.nPropDis		, true );   //구조물 ??챨타?
			m_OptionManager.SetValueInt( "GRAPHIC_SPEEDDIS"			, m_curData.nSpeedDis		, true );   //나무   표시거리
			m_OptionManager.SetValueInt( "GRAPHIC_GRASSDIS"			, m_curData.nGrassDis		, true );   //풀     표시거리
			m_OptionManager.SetValueInt( "GRAPHIC_AVATARDIS"		, m_curData.nAvatarDis		, true );   //캐릭터 표시거리
			m_OptionManager.SetValueInt( "GRAPHIC_SHADOWDIS"		, m_curData.nShadowDis		, true );   //그림자 표시거리
			m_OptionManager.SetValueInt( "GRAPHIC_LOWSHADOW"        , m_curData.nLowShadow      , true );   //저사양 그림자

			m_OptionManager.SetValueInt( "GRAPHIC_SPEEDQUAL"		, m_curData.nSpeedQual		, true );   //나무 품질
			m_OptionManager.SetValueInt( "GRAPHIC_MIPBIAS"			, m_curData.nMipBias		, true );   //텍스쳐 밉바이어스
			m_OptionManager.SetValueInt( "GRAPHIC_SELFSHADOWQUAL"	, m_curData.nSelfShadowQual	, true );	//셀프 그림자 품질
			m_OptionManager.SetValueInt( "GRAPHIC_GLOWQUAL"			, m_curData.nGlowQual		, true );   //Glow 품질

			m_OptionManager.SetValueInt( "GRAPHIC_WATERQUAL"		, m_curData.nWaterQual		, true );   //물 ??사 효과
			m_OptionManager.SetValueInt( "GRAPHIC_RESOURCEQUAL"		, m_curData.nResourceQual	, true );   //리소스 품질

			m_OptionManager.SetValueInt( "GRAPHIC_BRIGHT"			, m_curData.nBright			, true );   //화면 밝기
			m_OptionManager.SetValueInt( "GRAPHIC_WINBRIGHT"		, m_curData.nWinBright		, true );   //바탕화면 밝기 적용
			m_OptionManager.SetValueInt( "GRAPHIC_PRESETOPTION"		, m_curData.nPresetOption	, true );   //프리셋 모드

			m_OptionManager.SetValueInt( "GRAPHIC_TOWNLIMIT"		, m_curData.nTownLimit		, true );	//마을내 ?玲?구조물 표시

			m_OptionManager.SetValueInt( "GRAPHIC_TREEALPHA"		, m_curData.nTreeAlpha		, true );	//나무 투명화

			m_OptionManager.SetValueInt( "GRAPHIC_ENHANCE"			, m_curData.nEnhance		, true );	//강화 이펙트 표시

			m_OptionManager.SetValueInt( "GRAPHIC_STATE_EFFECT"			, m_curData.nStateEffect			, true );	//지속효과 이펙트 표시
			m_OptionManager.SetValueInt( "GRAPHIC_STATE_EFFECT_CREATURE"	, m_curData.nStateEffectPlayer	, true );	//자신과 크리처 지속효과
			m_OptionManager.SetValueInt( "GRAPHIC_STATE_EFFECT_PARTY"		, m_curData.nStateEffectParty	, true );	//파티원 지속효과
			m_OptionManager.SetValueInt( "GRAPHIC_STATE_EFFECT_ENEMY"		, m_curData.nStateEffectEnemy	, true );	//적 지속효과

			m_OptionManager.SetValueInt( "GRAPHIC_SHADOW"			, m_curData.nShadow			, true );	//그림자 표시

			m_OptionManager.SetValueInt( "GRAPHIC_RENDERTREE"		, m_curData.nRenderTree		, true );	//나무 표시
			m_OptionManager.SetValueInt( "GRAPHIC_RENDERGRASS"		, m_curData.nRenderGrass	, true );	//풀 표시
			m_OptionManager.SetValueInt( "GRAPHIC_LIGHT"			, m_curData.nLightMap		, true );	//라이??멥 

			m_OptionManager.SetValueInt( "GRAPHIC_EFFECT"			, m_curData.nEffect			, true );	//이펙트 표시
			m_OptionManager.SetValueInt( "GRAPHIC_EFFECT_CREATURE"	, m_curData.nEffectPlayer	, true );	//자신과 크리처
			m_OptionManager.SetValueInt( "GRAPHIC_EFFECT_PARTY"		, m_curData.nEffectParty	, true );	//파티원
			m_OptionManager.SetValueInt( "GRAPHIC_EFFECT_ENEMY"		, m_curData.nEffectEnemy	, true );	//적

			m_OptionManager.SetValueInt( "GRAPHIC_FACE_ANI"         , m_curData.nFaceAni        , true );  //눈 깜빡

			// 사운드
			m_OptionManager.SetValueInt( "SOUND_ALL_MUTE"			, m_curData.nAllMute		, true );
		//	m_OptionManager.SetValueInt( "SOUND_REPEAT"				, m_curData.nRepeat			, true ); // 2011.11.29 - servantes : 옵션 nui에 해당 효과 없음 / 주석처리
			m_OptionManager.SetValueInt( "SOUND_BGM_MUTE"			, m_curData.nBGM_Mute		, true );
			m_OptionManager.SetValueInt( "SOUND_SFX_MUTE"			, m_curData.nSFX_Mute		, true );
			m_OptionManager.SetValueInt( "SOUND_ENVS_MUTE"			, m_curData.nENVS_Mute		, true );

			m_OptionManager.SetValueInt( "SOUND_BGM_VOLUME"			, m_curData.nBGM_Volume		, true );
			m_OptionManager.SetValueInt( "SOUND_SFX_VOLUME"			, m_curData.nSFX_Volume		, true );
			m_OptionManager.SetValueInt( "SOUND_ENVS_VOLUME"		, m_curData.nENVS_Volume	, true );
			m_OptionManager.SetValueInt( "SOUND_MASTER_VOLUME"		, m_curData.nMASTER_Volume	, true );

			//LOBBY
			m_OptionManager.SetValueInt( "LOBBY_THEME"				, m_curData.nLobby_Theme    , true );

			m_OptionManager.SetValueInt( "GRAPHIC_RENDER_OTHERPLAYER", m_curData.nRenderOtherPlayer, true );

			break;
		}
	case SGAME_OPT_DATA::MODE_PLAY:
		{
			//	게임 플레이 관련 옵션
			m_OptionManager.SetValueInt( "PLAY_TAB"					, m_curData.nTABKey			, true );	//TAB키 설정
			m_OptionManager.SetValueInt( "PLAY_ENTERCHAT"			, m_curData.nEnterChat		, true );	//앤터체팅사용
			m_OptionManager.SetValueInt( "PLAY_CHIPATTACK"			, m_curData.nChipAttack		, true );	//포스칩 후 자동 공격
			m_OptionManager.SetValueInt( "PLAY_TRADE"				, m_curData.nTrade			, true );	//?킹?및 초대 거절
			m_OptionManager.SetValueInt( "PLAY_PVP"					, m_curData.nPVP			, true );	//대련신청_거부
			m_OptionManager.SetValueInt( "PLAY_AUTOTARGET"	, m_curData.nAutoTarget, true );				//공격_시_자동타겟팅
			m_OptionManager.SetValueInt( "PLAY_WHEEL"				, m_curData.nWheel			, true );	//휠방향_반전
			m_OptionManager.SetValueInt( "PLAY_CHATHIDE"			, m_curData.nChatHide		, true );	//체팅창 자동숨김
			m_OptionManager.SetValueInt( "PLAY_MOBFACE"				, m_curData.nMobFace		, true );	//몬스터 페이스컷
			m_OptionManager.SetValueInt( "PLAY_RAK"					, m_curData.nSimpleRak		, true );	//라크표시
			m_OptionManager.SetValueInt( "PLAY_CHATBALLOON"			, m_curData.nChatBalloon	, true );	//말풍선 표시
			m_OptionManager.SetValueInt( "PLAY_TIP"					, m_curData.nTip			, true );	//게임팁 표시
			// 2010.05.20 - prodongi
			//m_OptionManager.SetValueInt( "PLAY_HELM"				, m_curData.nHelm			, true );	//투구 보이기
			m_OptionManager.SetValueInt( "PLAY_MANTLE"				, m_curData.nMantle			, true );	//망토 보이기
			m_OptionManager.SetValueInt( "PLAY_HPGAGE"				, m_curData.nHPGage			, true );	//체력게이지 표시
			m_OptionManager.SetValueInt( "PLAY_PLAYERGAGE"			, m_curData.nPlayerGage		, true );	//자신과 파티원
			m_OptionManager.SetValueInt( "PLAY_MOBGAGE"				, m_curData.nMobGage		, true );	//몬스터
			m_OptionManager.SetValueInt( "PLAY_TARGETGAGE"			, m_curData.nTargetGage		, true );	//타겟
			m_OptionManager.SetValueInt( "PLAY_NAME"				, m_curData.nName			, true );	//이름 표시
			m_OptionManager.SetValueInt( "PLAY_PLAYERNAME"			, m_curData.nPlayerName		, true );	//플레이어
			m_OptionManager.SetValueInt( "PLAY_CREATURENAME"		, m_curData.nCreatureName	, true );	//크리처
			m_OptionManager.SetValueInt( "PLAY_MOBNAME"				, m_curData.nMobName		, true );	//몬스터
			m_OptionManager.SetValueInt( "PLAY_NPCNAME"				, m_curData.nNPCName		, true );	//NPC
			m_OptionManager.SetValueInt( "PLAY_DAMAGE"				, m_curData.ndamage			, true );	//데미지 표시
			m_OptionManager.SetValueInt( "PLAY_PLAYERDM"			, m_curData.nPlayerDM		, true );	//자신
			m_OptionManager.SetValueInt( "PLAY_CREATUREDM"			, m_curData.nCreatureDM		, true );	//크리처
			m_OptionManager.SetValueInt( "PLAY_PARTYDM"				, m_curData.nPartyDM		, true );	//파티원
			m_OptionManager.SetValueInt( "PLAY_WINLOCK"				, m_curData.nWinLock		, true );	//현??윈도우장금
			m_OptionManager.SetValueInt( "PLAY_WINALPHA"			, m_curData.nWinAlpha		, true );	//윈도우 투명도 설정
			m_OptionManager.SetValueInt( "PLAY_BOOTHTYPE"			, m_curData.nSelfBoothType	, true );	//간단노점
			m_OptionManager.SetValueInt( "PLAY_CRITICAL_CAMERA"     , m_curData.nCriticalCamera , true );	//크리티칼 카메라 진동
//			m_OptionManager.SetValueInt( "PLAY_AVATAR_DECO"         , m_curData.nAvatarDeco     , true );	//꾸미기 아이템 적용 // 2010.10.11. 게임플레이옵션에서 "꾸미기보이기" 제거.
			m_OptionManager.SetValueInt( "PLAY_WEATHER_QUALITY"		, m_curData.nWeatherQuality	, true );	//날씨 효과 품질
			m_OptionManager.SetValueInt( "PLAY_CAMERA_COLLISION"	, m_curData.nCameraCollision, true );	//카메라 충돌
			m_OptionManager.SetValueInt( "PLAY_TITLE_SHOW"	, m_curData.nTitleShow, true );	//호칭
			m_OptionManager.SetValueInt( "PLAY_SELECT_OUTLINE_SHOW"	, m_curData.isShowSelectOutLine, true );	
			break;
		}
	}
}

void SGameOption::Apply( int nMode )
{
	switch(nMode)
	{
	case SGAME_OPT_DATA::MODE_ENVIRONMENT:
		{
			SetOptionData( SGAME_OPT_DATA::MODE_ENVIRONMENT );
		}
		break;
	case SGAME_OPT_DATA::MODE_PLAY:
		{
			SetOptionData( SGAME_OPT_DATA::MODE_PLAY );

			m_OptionManager.SetValueInt( "MINIMAP_ALPHA"	, m_nMinimapAlpha	);
			m_OptionManager.SetValueInt( "MINIMAP_OPEN"		, m_nMinimapOpen	);
		}
		break;
	case SGAME_OPT_DATA::MODE_UI:
		{
			m_OptionManager.SetValueInt( "INTERFACE_FACECUT", m_nFaceCut	);
			m_OptionManager.SetValueInt( "INTERFACE_MINIMAP", m_nMinimap	);
			m_OptionManager.SetValueInt( "INTERFACE_ZOOM"	, m_nZoom		);
		}
		break;
	}
}

void SGameOption::ChatOptionApply( int nTabType, bool * pCehck )
{
	if( nTabType < 0 || nTabType > 4 ) return;

	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )
	{
		m_bChannelCheck[nTabType][i] = pCehck[i];
	}
	Save();	// 2012. 1. 26 - marine 채팅옵션의 확인을 누를때 저장하도록 수정(여기서 하지 않으면 로그아웃, 클라이언트 이상종료, 등등의 이유로 채팅옵션이 저장되지 않는 경우 발생
}

void SGameOption::ChatOptionApply( int nTabType, std::string strValue )
{
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )
	{
		std::string str = strValue.substr( i, 1 );
		switch(nTabType)
		{
		case 0:	m_bChannelCheck[nTabType][i] = !!(::atoi( str.c_str() ));	break;
		case 1:	m_bChannelCheck[nTabType][i] = !!(::atoi( str.c_str() ));	break;
		case 2:	m_bChannelCheck[nTabType][i] = !!(::atoi( str.c_str() ));	break;
		case 3:	m_bChannelCheck[nTabType][i] = !!(::atoi( str.c_str() ));	break;
		case 4:	m_bChannelCheck[nTabType][i] = !!(::atoi( str.c_str() ));	break;
		}
	}
	Save();	// 2012. 1. 26 - marine 채팅옵션의 확인을 누를때 저장하도록 수정(여기서 하지 않으면 로그아웃, 클라이언트 이상종료, 등등의 이유로 채팅옵션이 저장되지 않는 경우 발생
}

void SGameOption::Save()
{
	// 저장
	SetOptionData( SGAME_OPT_DATA::MODE_ENVIRONMENT );
	SetOptionData( SGAME_OPT_DATA::MODE_PLAY );

	m_OptionManager.SetValueInt( "MINIMAP_ALPHA"	, m_nMinimapAlpha	);
	m_OptionManager.SetValueInt( "MINIMAP_OPEN"		, m_nMinimapOpen	);
	
	// UI
	m_OptionManager.SetValueInt( "INTERFACE_FACECUT", m_nFaceCut	);
	m_OptionManager.SetValueInt( "INTERFACE_MINIMAP", m_nMinimap	);
	m_OptionManager.SetValueInt( "INTERFACE_ZOOM"	, m_nZoom		);

	// 인터페이스
	//m_OptionManager.SetValueInt( "QUICK_VER_X"		, m_nQuickVerX		);
	//m_OptionManager.SetValueInt( "QUICK_VER_Y"		, m_nQuickVerY		);
	m_OptionManager.SetValueInt( "QUICK_HOZ_X"		, m_nQuickHozX		);
	m_OptionManager.SetValueInt( "QUICK_HOZ_Y"		, m_nQuickHozY		);
	m_OptionManager.SetValueInt( "QUICK_VER_OPEN"	, m_nVerticalQuick	);

	//m_OptionManager.SetValueInt( "STATE_VER_X"		, m_nStateVerX		);
	//m_OptionManager.SetValueInt( "STATE_VER_Y"		, m_nStateVerY		);
	m_OptionManager.SetValueInt( "STATE_HOZ_X"		, m_nStateHozX		);
	m_OptionManager.SetValueInt( "STATE_HOZ_Y"		, m_nStateHozY		);
	m_OptionManager.SetValueInt( "STATE_VER_OPEN"	, m_nVerticalState	);

	m_OptionManager.SetValueInt( "MESSANGER_X"		, m_nMessangerX		);
	m_OptionManager.SetValueInt( "MESSANGER_Y"		, m_nMessangerY		);
	m_OptionManager.SetValueInt( "MESSANGER_OPEN"	, m_nMessangerOpen	);

	m_OptionManager.SetValueInt( "PARTY_X"			, m_nPartyX		);
	m_OptionManager.SetValueInt( "PARTY_Y"			, m_nPartyY		);

	m_OptionManager.SetValueInt( "CREAUTRE_OPEN"	, m_nCreatureOpen	);

	m_OptionManager.SetValueInt( "SYSMENU_X", m_nSysMenuX );
	m_OptionManager.SetValueInt( "SYSMENU_Y", m_nSysMenuY );

	m_OptionManager.SetValueInt( "INVENTORY_X", m_nInventoryX );
	m_OptionManager.SetValueInt( "INVENTORY_Y", m_nInventoryY );

	m_OptionManager.SetValueInt( "CHATTING_LINE"	, m_nChattingLine	);
	m_OptionManager.SetValueInt( "CHATTING_HEIGHT"	, m_nChattingHeight );

	m_OptionManager.SetValueInt( "CREATURE_X", m_nCreatureX );
	m_OptionManager.SetValueInt( "CREATURE_Y", m_nCreatureY );

	m_OptionManager.SetValueInt( "CREATURE_INFO_X", m_nCreatureInfoX );
	m_OptionManager.SetValueInt( "CREATURE_INFO_Y", m_nCreatureInfoY );

	m_OptionManager.SetValueInt( "QUEST_X", m_nQuestX );
	m_OptionManager.SetValueInt( "QUEST_Y", m_nQuestY );

	m_OptionManager.SetValueInt( "MOTION_X", m_nMotionX );
	m_OptionManager.SetValueInt( "MOTION_Y", m_nMotionY );

	m_OptionManager.SetValueInt( "OPTION_X", m_nOptionX );
	m_OptionManager.SetValueInt( "OPTION_Y", m_nOptionY );

	m_OptionManager.SetValueInt( "CHAR_X", m_nCharX );
	m_OptionManager.SetValueInt( "CHAR_Y", m_nCharY );

	m_OptionManager.SetValueInt( "SKILL_X", m_nSkillX );
	m_OptionManager.SetValueInt( "SKILL_Y", m_nSkillY );

	m_OptionManager.SetValueInt( "SYSTEM_X", m_nSystemX );
	m_OptionManager.SetValueInt( "SYSTEM_Y", m_nSystemY );

	m_OptionManager.SetValueInt( "MAP_X", m_nMapX );
	m_OptionManager.SetValueInt( "MAP_Y", m_nMapY );

	m_OptionManager.SetValueInt( "ITEM_COMBINE_X", m_nItemCombineX );
	m_OptionManager.SetValueInt( "ITEM_COMBINE_Y", m_nItemCombineY );

	m_OptionManager.SetValueInt( "SHOP_X", m_nShopX );
	m_OptionManager.SetValueInt( "SHOP_Y", m_nShopY );

	m_OptionManager.SetValueInt( "STORE_X", m_nStoreX );
	m_OptionManager.SetValueInt( "STORE_Y", m_nStoreY );

	m_OptionManager.SetValueInt( "STORAGE_X", m_nStorageX );
	m_OptionManager.SetValueInt( "STORAGE_Y", m_nStorageY );

	// 장비창 위치저장. bintitle. 2010.10.07.
	m_OptionManager.SetValueInt( "EQUIPMENT_X", m_nPosEquipment.x );
	m_OptionManager.SetValueInt( "EQUIPMENT_Y", m_nPosEquipment.y );

	m_OptionManager.SetValueInt( "OPEN_EQUIP_WND_FLAG", m_bOpenEquipWnd ); //servantes 2010.11.02

	/// 2011.02.16 - prodongi
	m_OptionManager.SetValueInt("USE_RECHARGE_MSGBOX", m_useRechargeMsgBox);

	// 채팅
	std::string strValue;	
	strValue.clear();
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )	strValue += CStringUtil::StringFormat( "%d", m_bChannelCheck[0][i] );
	if( strValue.size() == SGAME_OPT_DATA::c_nMaxChatOption )	m_OptionManager.SetValueString( "CHAT_CHANNEL_00", strValue );

	strValue.clear();
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )	strValue += CStringUtil::StringFormat( "%d", m_bChannelCheck[1][i] );
	if( strValue.size() == SGAME_OPT_DATA::c_nMaxChatOption )	m_OptionManager.SetValueString( "CHAT_CHANNEL_01", strValue );

	strValue.clear();
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )	strValue += CStringUtil::StringFormat( "%d", m_bChannelCheck[2][i] );
	if( strValue.size() == SGAME_OPT_DATA::c_nMaxChatOption )	m_OptionManager.SetValueString( "CHAT_CHANNEL_02", strValue );

	strValue.clear();
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )	strValue += CStringUtil::StringFormat( "%d", m_bChannelCheck[3][i] );
	if( strValue.size() == SGAME_OPT_DATA::c_nMaxChatOption )	m_OptionManager.SetValueString( "CHAT_CHANNEL_03", strValue );

	strValue.clear();
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )	strValue += CStringUtil::StringFormat( "%d", m_bChannelCheck[4][i] );
	if( strValue.size() == SGAME_OPT_DATA::c_nMaxChatOption )	m_OptionManager.SetValueString( "CHAT_CHANNEL_04", strValue );

	// 채널명
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChannel; i++ )
		m_OptionManager.SetValueString( CStringUtil::StringFormat( "CHAT_TAB_NAME_%d", i ).c_str(), m_strTabName[i].c_str() );

	// 채널명
	for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChannel; i++ )
		m_OptionManager.SetValueString( CStringUtil::StringFormat( "CHAT_TAB_MARK_%d", i ).c_str(), m_strTabMark[i].c_str() );

	m_OptionManager.SetValueInt( "CREATURESKILL_X", m_nCreatureSkillX );
	m_OptionManager.SetValueInt( "CREATURESKILL_Y", m_nCreatureSkillY );
	
}

void SGameOption::Destroy()
{
	Save();
}

void SGameOption::OptionDataBind()
{
	ENV().Bind( "opt.ev.GRAPHIC_RESOLUTION_WIDTH"	, &m_curData.nResolution_Width  );
	ENV().Bind( "opt.ev.GRAPHIC_RESOLUTION_HEIGHT"	, &m_curData.nResolution_Height  );

	ENV().Bind( "opt.ev.GRAPHIC_REFRESHRATE"		, &m_curData.nRefreshRate	  );
	ENV().Bind( "opt.ev.GRAPHIC_WINMODE"			, &m_curData.nWinMode		  );
	ENV().Bind( "opt.ev.GRAPHIC_FULLWINMODE"		, &m_curData.nFullWinMode	  );
												 									
	ENV().Bind( "opt.ev.GRAPHIC_BACKGRONDDIS"		, &m_curData.nBackGrondDis	  );
	ENV().Bind( "opt.ev.GRAPHIC_TERRAINDIS"			, &m_curData.nTerrainDis	  );
	ENV().Bind( "opt.ev.GRAPHIC_PROPDIS"			, &m_curData.nPropDis		  );
	ENV().Bind( "opt.ev.GRAPHIC_SPEEDDIS"			, &m_curData.nSpeedDis		  );
	ENV().Bind( "opt.ev.GRAPHIC_GRASSDIS"			, &m_curData.nGrassDis		  );
	ENV().Bind( "opt.ev.GRAPHIC_AVATARDIS"			, &m_curData.nAvatarDis	  );
	ENV().Bind( "opt.ev.GRAPHIC_SHADOWDIS"			, &m_curData.nShadowDis	  );
	ENV().Bind( "opt.ev.GRAPHIC_LOWSHADOW"			, &m_curData.nLowShadow      );   
												 									
	ENV().Bind( "opt.ev.GRAPHIC_SPEEDQUAL"			, &m_curData.nSpeedQual	  );
	ENV().Bind( "opt.ev.GRAPHIC_MIPBIAS"			, &m_curData.nMipBias		  );
	ENV().Bind( "opt.ev.GRAPHIC_SELFSHADOWQUAL"		, &m_curData.nSelfShadowQual );
	ENV().Bind( "opt.ev.GRAPHIC_GLOWQUAL"			, &m_curData.nGlowQual		  );
												 									
	ENV().Bind( "opt.ev.GRAPHIC_WATERQUAL"			, &m_curData.nWaterQual	  );
	ENV().Bind( "opt.ev.GRAPHIC_RESOURCEQUAL"		, &m_curData.nResourceQual	  );
												 									
	ENV().Bind( "opt.ev.GRAPHIC_BRIGHT"				, &m_curData.nBright		  );
	ENV().Bind( "opt.ev.GRAPHIC_WINBRIGHT"			, &m_curData.nWinBright	  );
	ENV().Bind( "opt.ev.GRAPHIC_PRESETOPTION"		, &m_curData.nPresetOption	  );

	ENV().Bind( "opt.ev.GRAPHIC_TOWNLIMIT"			, &m_curData.nTownLimit	  );

	ENV().Bind( "opt.ev.GRAPHIC_TREEALPHA"			, &m_curData.nTreeAlpha	  );

	ENV().Bind( "opt.ev.GRAPHIC_ENHANCE"			, &m_curData.nEnhance		  );

	ENV().Bind( "opt.ev.GRAPHIC_STATE_EFFECT"			, &m_curData.nStateEffect		);
	ENV().Bind( "opt.ev.GRAPHIC_STATE_EFFECT_PLAYER"	, &m_curData.nStateEffectPlayer	);
	ENV().Bind( "opt.ev.GRAPHIC_STATE_EFFECT_PARTY"		, &m_curData.nStateEffectParty	);
	ENV().Bind( "opt.ev.GRAPHIC_STATE_EFFECT_ENEMY"		, &m_curData.nStateEffectEnemy	);

	ENV().Bind( "opt.ev.GRAPHIC_SHADOW"				, &m_curData.nShadow		);

	ENV().Bind( "opt.ev.GRAPHIC_RENDERTREE"			, &m_curData.nRenderTree	);
	ENV().Bind( "opt.ev.GRAPHIC_RENDERGRASS"		, &m_curData.nRenderGrass	);
	ENV().Bind( "opt.ev.GRAPHIC_LIGHT"				, &m_curData.nLightMap	);

	ENV().Bind( "opt.ev.GRAPHIC_EFFECT"				, &m_curData.nEffect		);
	ENV().Bind( "opt.ev.GRAPHIC_EFFECT_PLAYER"		, &m_curData.nEffectPlayer	);
	ENV().Bind( "opt.ev.GRAPHIC_EFFECT_PARTY"		, &m_curData.nEffectParty	);
	ENV().Bind( "opt.ev.GRAPHIC_EFFECT_ENEMY"		, &m_curData.nEffectEnemy	);
												
	ENV().Bind( "opt.ev.SOUND_ALL_MUTE"				, &m_curData.nAllMute		);
//	ENV().Bind( "opt.ev.SOUND_REPEAT"			    , &m_curData.nRepeat		);  // 2011.11.29 - servantes : 옵션 nui에 해당 효과 없음 / 주석처리
	ENV().Bind( "opt.ev.SOUND_BGM_MUTE"				, &m_curData.nBGM_Mute		);
	ENV().Bind( "opt.ev.SOUND_ENVS_MUTE"			, &m_curData.nENVS_Mute		);

	ENV().Bind( "opt.ev.SOUND_BGM_VOLUME"			, &m_curData.nBGM_Volume	);
	ENV().Bind( "opt.ev.SOUND_SFX_MUTE"				, &m_curData.nSFX_Mute		); 
	ENV().Bind( "opt.ev.SOUND_ENVS_VOLUME"			, &m_curData.nENVS_Volume	);
	ENV().Bind( "opt.ev.SOUND_MASTER_VOLUME"		, &m_curData.nMASTER_Volume	);

	ENV().Bind( "opt.ev.GRAPHIC_RENDER_OTHERPLAYER"	, &m_curData.nRenderOtherPlayer );

	ENV().Bind( "opt.pl.PLAY_TAB"					, &m_curData.nTABKey		);
	ENV().Bind( "opt.pl.PLAY_ENTERCHAT"				, &m_curData.nEnterChat		);
	ENV().Bind( "opt.pl.PLAY_CHIPATTACK"			, &m_curData.nChipAttack	);	
	ENV().Bind( "opt.pl.PLAY_TRADE"					, &m_curData.nTrade			);
	ENV().Bind( "opt.pl.PLAY_PVP"					, &m_curData.nPVP			);
	ENV().Bind( "opt.pl.PLAY_AUTO_TARGET"			, &m_curData.nAutoTarget );		// 공격_시_자동타겟팅
	ENV().Bind( "opt.pl.PLAY_WHEEL"					, &m_curData.nWheel			);
	ENV().Bind( "opt.pl.PLAY_CHATHIDE"				, &m_curData.nChatHide		);
	ENV().Bind( "opt.pl.PLAY_MOBFACE"				, &m_curData.nMobFace		);
	ENV().Bind( "opt.pl.PLAY_RAK"					, &m_curData.nSimpleRak		);
	ENV().Bind( "opt.pl.PLAY_CHATBALLOON"			, &m_curData.nChatBalloon	);
	ENV().Bind( "opt.pl.PLAY_TIP"					, &m_curData.nTip			);
	// 2010.05.20 - prodongi
	//ENV().Bind( "opt.pl.PLAY_HELM"					, &m_curData.nHelm			);
	ENV().Bind( "opt.pl.PLAY_MANTLE"				, &m_curData.nMantle		);	
	ENV().Bind( "opt.pl.PLAY_HPGAGE"				, &m_curData.nHPGage		);	
	ENV().Bind( "opt.pl.PLAY_PLAYERGAGE"			, &m_curData.nPlayerGage	);	
	ENV().Bind( "opt.pl.PLAY_MOBGAGE"				, &m_curData.nMobGage		);
	ENV().Bind( "opt.pl.PLAY_TARGETGAGE"			, &m_curData.nTargetGage	);	
	ENV().Bind( "opt.pl.PLAY_NAME"					, &m_curData.nName			);
	ENV().Bind( "opt.pl.PLAY_PLAYERNAME"			, &m_curData.nPlayerName	);	
	ENV().Bind( "opt.pl.PLAY_CREATURENAME"			, &m_curData.nCreatureName	);
	ENV().Bind( "opt.pl.PLAY_MOBNAME"				, &m_curData.nMobName		);
	ENV().Bind( "opt.pl.PLAY_NPCNAME"				, &m_curData.nNPCName		);
	ENV().Bind( "opt.pl.PLAY_DAMAGE"				, &m_curData.ndamage		);	
	ENV().Bind( "opt.pl.PLAY_PLAYERDM"				, &m_curData.nPlayerDM		);
	ENV().Bind( "opt.pl.PLAY_CREATUREDM"			, &m_curData.nCreatureDM	);	
	ENV().Bind( "opt.pl.PLAY_PARTYDM"				, &m_curData.nPartyDM		);
	ENV().Bind( "opt.pl.PLAY_WINLOCK"				, &m_curData.nWinLock		);
	ENV().Bind( "opt.pl.PLAY_WINALPHA"				, &m_curData.nWinAlpha		);
	ENV().Bind( "opt.pl.PLAY_BOOTHTYPE"				, &m_curData.nSelfBoothType );
	ENV().Bind( "opt.pl.PLAY_CRITICAL_CAMERA"       , &m_curData.nCriticalCamera);
//	ENV().Bind( "opt.pl.PLAY_AVATAR_DECO"			, &m_curData.nAvatarDeco    ); // 2010.10.11. 게임플레이옵션에서 "꾸미기보이기" 제거.
	ENV().Bind( "opt.pl.PLAY_WEATHER_QUALITY"		, &m_curData.nWeatherQuality);
	ENV().Bind( "opt.pl.PLAY_CAMERA_COLLISION"		, &m_curData.nCameraCollision);
	ENV().Bind( "opt.pl.PLAY_TITLE_SHOW"		, &m_curData.nTitleShow);	// 2012. 5. 24 - marine
	ENV().Bind( "opt.pl.PLAY_SELECT_OUTLINE_SHOW"		, &m_curData.isShowSelectOutLine);
}

void SGameOption::SetCrrOptionData()
{
	m_curData.nResolution_Width  = CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_RESOLUTION_WIDTH" , true ), 1024);   //해상도 가로
	m_curData.nResolution_Height = CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_RESOLUTION_HEIGHT", true ), 768);   //해상도 세로

	//if( m_curData.nResolution_Width  <= 0 ) m_curData.nResolution_Width  = 1024;
	//if( m_curData.nResolution_Height <= 0 ) m_curData.nResolution_Height = 768;

	m_curData.nRefreshRate		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_REFRESHRATE"	, true ), m_curData.nRefreshRate);
	m_curData.nWinMode			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_WINMODE"		, true ), m_curData.nWinMode);
	m_curData.nFullWinMode		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_FULLWINMODE"	, true ), m_curData.nFullWinMode);

	m_curData.nBackGrondDis		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_BACKGROUNDDIS"	, true ), m_curData.nBackGrondDis);
	m_curData.nTerrainDis		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_TERRAINDIS"	, true ), m_curData.nTerrainDis);
	m_curData.nPropDis			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_PROPDIS"		, true ), m_curData.nPropDis);	 
	m_curData.nSpeedDis			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_SPEEDDIS"		, true ), m_curData.nSpeedDis);		  
	m_curData.nGrassDis			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_GRASSDIS"		, true ), m_curData.nGrassDis);		  
	m_curData.nAvatarDis		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_AVATARDIS"		, true ), m_curData.nAvatarDis);	  
	m_curData.nShadowDis		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_SHADOWDIS"		, true ), m_curData.nShadowDis);  
	m_curData.nLowShadow        =   CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_LOWSHADOW"		, true ), 0);  

	//if( m_curData.nLowShadow < 0 ) m_curData.nLowShadow = 0;

	m_curData.nSpeedQual		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_SPEEDQUAL"		, true ), m_curData.nSpeedQual);	
	m_curData.nMipBias			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_MIPBIAS"		, true ), m_curData.nMipBias);	
	m_curData.nSelfShadowQual	=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_SELFSHADOWQUAL", true ), m_curData.nSelfShadowQual);
	m_curData.nGlowQual			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_GLOWQUAL"		, true ), m_curData.nGlowQual);		  
																												  
	m_curData.nWaterQual		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_WATERQUAL"		, true ), m_curData.nWaterQual);	  
	m_curData.nResourceQual		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_RESOURCEQUAL"	, true ), m_curData.nResourceQual);
																												  
	m_curData.nBright			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_BRIGHT"		, true ), m_curData.nBright);		 
	m_curData.nWinBright		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_WINBRIGHT"		, true ), m_curData.nWinBright);
	m_curData.nPresetOption		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_PRESETOPTION"	, true ), 4);
	//if( m_curData.nPresetOption < 0 ) m_curData.nPresetOption = 4;

	m_curData.nTownLimit		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_TOWNLIMIT", true ), 0);
	//if( m_curData.nTownLimit < 0 ) m_curData.nTownLimit = 0;

	m_curData.nTreeAlpha		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_TREEALPHA"		, true ),		m_curData.nTreeAlpha	);
																														
	m_curData.nEnhance			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_ENHANCE"			, true ),	m_curData.nEnhance		);
																														
	m_curData.nRenderTree		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_RENDERTREE"		, true ),	m_curData.nRenderTree	);
	m_curData.nRenderGrass		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_RENDERGRASS"		, true ),	m_curData.nRenderGrass	);
	m_curData.nLightMap			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_LIGHT"			, true ),		m_curData.nLightMap		);

	m_curData.nStateEffect			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_STATE_EFFECT"			, true ), m_curData.nStateEffect		);
	m_curData.nStateEffectPlayer	=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_STATE_EFFECT_CREATURE", true ),  m_curData.nStateEffectPlayer	);
	m_curData.nStateEffectParty		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_STATE_EFFECT_PARTY"	, true ), m_curData.nStateEffectParty	);
	m_curData.nStateEffectEnemy		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_STATE_EFFECT_ENEMY"	, true ), m_curData.nStateEffectEnemy	);

	m_curData.nEffect			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_EFFECT"			, true ), m_curData.nEffect			);
	m_curData.nEffectPlayer		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_EFFECT_CREATURE"	, true ), m_curData.nEffectPlayer	);	  
	m_curData.nEffectParty		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_EFFECT_PARTY"	, true ),	  m_curData.nEffectParty	);	
	m_curData.nEffectEnemy		=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_EFFECT_ENEMY"	, true ),	  m_curData.nEffectEnemy	);	
																													  
	m_curData.nFaceAni          = 	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_FACE_ANI"     , true ),	  m_curData.nFaceAni		); //눈깜빡
																													  
	m_curData.nShadow			=	CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_SHADOW"	, true ),		  m_curData.nShadow			);

	//사운드
	m_curData.nAllMute			= CheckIntValue( m_OptionManager.GetValueInt( "SOUND_ALL_MUTE"		, true ), m_curData.nAllMute		);
//	m_curData.nRepeat			= CheckIntValue( m_OptionManager.GetValueInt( "SOUND_REPEAT"		, true ), m_curData.nRepeat			);  // 2011.11.29 - servantes : 옵션 nui에 해당 효과 없음 / 주석처리
	m_curData.nBGM_Mute         = CheckIntValue( m_OptionManager.GetValueInt( "SOUND_BGM_MUTE"		, true ), m_curData.nBGM_Mute      	);
	m_curData.nSFX_Mute         = CheckIntValue( m_OptionManager.GetValueInt( "SOUND_SFX_MUTE"		, true ), m_curData.nSFX_Mute      	);
	m_curData.nENVS_Mute        = CheckIntValue( m_OptionManager.GetValueInt( "SOUND_ENVS_MUTE"	, true ),	  m_curData.nENVS_Mute     );
																											  
	m_curData.nBGM_Volume       = CheckIntValue( m_OptionManager.GetValueInt( "SOUND_BGM_VOLUME"	, true ), m_curData.nBGM_Volume    	);
	m_curData.nSFX_Volume       = CheckIntValue( m_OptionManager.GetValueInt( "SOUND_SFX_VOLUME"	, true ), m_curData.nSFX_Volume    	);
	m_curData.nENVS_Volume      = CheckIntValue( m_OptionManager.GetValueInt( "SOUND_ENVS_VOLUME"	, true ), m_curData.nENVS_Volume   	);
	m_curData.nMASTER_Volume    = CheckIntValue( m_OptionManager.GetValueInt( "SOUND_MASTER_VOLUME"	, true ), m_curData.nMASTER_Volume 	);

	//LOBBY
	m_curData.nLobby_Theme      = CheckIntValue( m_OptionManager.GetValueInt("LOBBY_THEME"				, true ),	m_curData.nLobby_Theme      );
																													
	m_curData.nRenderOtherPlayer = CheckIntValue( m_OptionManager.GetValueInt( "GRAPHIC_RENDER_OTHERPLAYER", true ),m_curData.nRenderOtherPlayer);

	//게임 플레이 관련
	m_curData.nTABKey			= m_OptionManager.GetValueInt( "PLAY_TAB"			, true );
	if( m_curData.nTABKey < 0 || m_curData.nTABKey > SGAME_OPT_DATA::MaxTapCase )
		m_curData.nTABKey = 0;
	m_curData.nEnterChat		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_ENTERCHAT"		, true ), false);
	m_curData.nChipAttack		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_CHIPATTACK"	, true ), true);
	m_curData.nTrade			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_TRADE"			, true ), false);
	m_curData.nPVP				= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_PVP"			, true ), false);
	m_curData.nAutoTarget		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_AUTOTARGET", true ), true );			// 공격 시 자동타겟팅
	m_curData.nWheel			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_WHEEL"			, true ), false);
	m_curData.nChatHide			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_CHATHIDE"		, true ), false);
	m_curData.nMobFace			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_MOBFACE"		, true ), false);
	m_curData.nSimpleRak		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_RAK"			, true ), true);
	m_curData.nChatBalloon		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_CHATBALLOON"	, true ), true);
	m_curData.nTip				= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_TIP"			, true ), true);
	// 2010.05.20 - prodongi
	//m_curData.nHelm				= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_HELM"			, true ), true);
	m_curData.nMantle			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_MANTLE"		, true ), true);
	m_curData.nHPGage			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_HPGAGE"		, true ), true);
	m_curData.nPlayerGage		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_PLAYERGAGE"	, true ), true);
	m_curData.nMobGage			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_MOBGAGE"		, true ), true);
	m_curData.nTargetGage		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_TARGETGAGE"	, true ), true);
	m_curData.nName				= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_NAME"			, true ), true);
	m_curData.nPlayerName		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_PLAYERNAME"	, true ), true);
	m_curData.nCreatureName		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_CREATURENAME"	, true ), true);
	m_curData.nMobName			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_MOBNAME"		, true ), true);
	m_curData.nNPCName			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_NPCNAME"		, true ), true);
	m_curData.ndamage			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_DAMAGE"		, true ), true);
	m_curData.nPlayerDM			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_PLAYERDM"		, true ), true);
	m_curData.nCreatureDM		= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_CREATUREDM"	, true ), true);
	m_curData.nPartyDM			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_PARTYDM"		, true ), false);
	m_curData.nWinLock			= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_WINLOCK"		, true ), false);
	m_curData.nWinAlpha			= CheckIntValue( m_OptionManager.GetValueInt( "PLAY_WINALPHA"		 , true ), m_curData.nWinAlpha			);
	m_curData.nSelfBoothType	= CheckIntValue( m_OptionManager.GetValueInt( "PLAY_BOOTHTYPE"		 , true ), m_curData.nSelfBoothType		);
	m_curData.nCriticalCamera   = CheckIntValue( m_OptionManager.GetValueInt( "PLAY_CRITICAL_CAMERA", true ),  m_curData.nCriticalCamera	);
		
	// 2010.10.11. 게임플레이옵션에서 "꾸미기보이기" 제거.
	// 꾸미기아이템보이기 체크박스가 제거된다.  항상 보임으로 설정. bintitle. 2010.10.07.
//	m_curData.nAvatarDeco = 1;
//	m_curData.nAvatarDeco       = CheckIntValue( m_OptionManager.GetValueInt( "PLAY_AVATAR_DECO"    , true ),  m_curData.nAvatarDeco		);

	m_curData.nWeatherQuality	= CheckIntValue( m_OptionManager.GetValueInt( "PLAY_WEATHER_QUALITY", true ),  m_curData.nWeatherQuality	);
	m_curData.nCameraCollision	= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_CAMERA_COLLISION", true ), true );
	m_curData.nTitleShow	= CheckBoolValue( m_OptionManager.GetValueInt( "PLAY_TITLE_SHOW", true ), true );
	m_curData.isShowSelectOutLine = CheckBoolValue(m_OptionManager.GetValueInt("PLAY_SELECT_OUTLINE_SHOW", true), true);
	if( m_curData.nCriticalCamera < 0 )
		m_curData.nCriticalCamera = 1;


	// 2010.10.11. 게임플레이옵션에서 "꾸미기보이기" 제거.
	//if( m_curData.nAvatarDeco < 0 )
	//	m_curData.nAvatarDeco = 1;

	if( m_curData.nWinAlpha < 0 || m_curData.nWinAlpha >= SGAME_OPT_DATA::MaxWinAlpha )
		m_curData.nWinAlpha = 0;
}

bool SGameOption::CheckBoolValue( int nValue, bool bDefaultValue )
{
	if( nValue != 0 && nValue != 1 )
		return bDefaultValue;
	else return nValue;
}

int SGameOption::CheckIntValue( int nValue, int bDefaultValue )
{
	if( nValue == ERR_RESULT )
		return bDefaultValue;
	else return nValue;
}
// 캐릭?? 상관없는 로드
void SGameOption::Init()
{
	//Local System Info
#define DIV 1024
	char *divisor = "K";

	MEMORYSTATUS stat;
	GlobalMemoryStatus (&stat);

	_oprint("The MEMORYSTATUS structure is %ld bytes long.\n"  , stat.dwLength                    );
	_oprint("It should be %d.\n"                               , sizeof (stat)                    );
	_oprint("There is %ld percent of memory in use.\n"         , stat.dwMemoryLoad                );
	_oprint("There are %ld total %sbytes of physical memory.\n", stat.dwTotalPhys/DIV    , divisor);
	_oprint("There are %ld free %sbytes of physical memory.\n" , stat.dwAvailPhys/DIV    , divisor);
	_oprint("There are %ld total %sbytes of paging file.\n"    , stat.dwTotalPageFile/DIV, divisor);
	_oprint("There are %ld free %sbytes of paging file.\n"     , stat.dwAvailPageFile/DIV, divisor);
	_oprint("There are %ld total %sbytes of virtual memory.\n" , stat.dwTotalVirtual/DIV , divisor);
	_oprint("There are %ld free %sbytes of virtual memory.\n"  , stat.dwAvailVirtual/DIV , divisor);

	SetPhysicalMemSize( stat.dwTotalPhys/(DIV*DIV) );
	
	int nMaxCount = 1000;
	int nFreeMem = stat.dwAvailPhys/(DIV*DIV);
	if( nFreeMem > 1024 )
	{
		nMaxCount = 1000;
#ifndef _RAPPELZ_CONFIG
		K3DRenderDeviceDX::SetRecycleMaxCount( nMaxCount );
#endif
		_oprint("Recycle Count : %d\n", nMaxCount );
	}
	else if( nFreeMem < 1024 && nFreeMem > 512 )
	{
		nMaxCount = 400;
#ifndef _RAPPELZ_CONFIG
		K3DRenderDeviceDX::SetRecycleMaxCount( nMaxCount );
#endif
		_oprint("Recycle Count : %d\n", nMaxCount );
	}
	else
	{
		nMaxCount = 200;
#ifndef _RAPPELZ_CONFIG
		K3DRenderDeviceDX::SetRecycleMaxCount( nMaxCount );
#endif
		_oprint("Recycle Count : %d\n", nMaxCount );
	}

	SetEnvironmenteDefault(m_defData);
	SetPlayDataDefault(m_defData);
	SetUIPosDefault();
	m_defData.nWinMode = 0;	//파일을 최초 읽지 못하는 경우 풀모드가 디폴트로 쎄팅

	m_curData = m_defData;
 
	if( m_OptionManager.LoadOptionFile() )
	{
		SetCrrOptionData();
	}
	Save();
	OptionDataBind();

/*	if( m_OptionManager.LoadOptionFile() )
	{
		SetCrrOptionData();
//		SetEnvironmenteDefault();
	}
	else
	{
		SetEnvironmenteDefault(m_defData);
		SetPlayDataDefault(m_defData);
		SetUIPosDefault();
		m_defData.nWinMode = 0;	//파일을 최초 읽지 못하는 경우 풀모드가 디폴트로 쎄팅

		m_curData = m_defData;

		Save();
	}
	OptionDataBind();*/

	if( m_curData.nAllMute < 0		|| m_curData.nAllMute > 1 )			m_curData.nAllMute    = 0;
	if( m_curData.nBGM_Mute < 0		|| m_curData.nBGM_Mute > 1 )		m_curData.nBGM_Mute   = 0;
	if( m_curData.nSFX_Mute < 0		|| m_curData.nSFX_Mute > 1 )		m_curData.nSFX_Mute   = 0;
	if( m_curData.nENVS_Mute < 0	|| m_curData.nENVS_Mute > 1 )		m_curData.nENVS_Mute   = 0;
	if( m_curData.nRenderOtherPlayer < 0 || m_curData.nRenderOtherPlayer > 1 ) m_curData.nRenderOtherPlayer = 0;

	if( m_curData.nBGM_Volume < 0	|| m_curData.nBGM_Volume > 9 )	m_curData.nBGM_Volume = 6;
	if( m_curData.nSFX_Volume < 0	|| m_curData.nSFX_Volume > 9 )	m_curData.nSFX_Volume = 8;
	if( m_curData.nENVS_Volume < 0	|| m_curData.nENVS_Volume > 9 )	m_curData.nENVS_Volume = 8;
	if( m_curData.nMASTER_Volume < 0	|| m_curData.nMASTER_Volume > 9 )	m_curData.nMASTER_Volume = 10;
}

void SGameOption::SetEnvironmenteDefault( _OPT_DATA& data )
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	게임 환경 관련 옵션
	
//	data.nRepeat		= 0; //0~1	현재음 반복 // 2011.11.29 - servantes : 옵션 nui에 해당 효과 없음 / 주석처리

	data.nBright       = 3;
	data.nWinBright	= 0; //0~1	바탕화면 밝기 적용
	data.nPresetOption = PRESET_MID; //3번이 기본

	data.nWinMode		= 1; //0~1	Full, Window
	data.nTreeAlpha	= 1; //0~1	나무 알파처리(투명화)

	std::string strCountry = ENV().GetString( "country" );
	if( strCountry == "<NULL>" )
	{
		data.nRenderOtherPlayer = 1;
	}
	else if( strCountry == "TW" )
	{
		data.nRenderOtherPlayer = 0;
	}
	else
		data.nRenderOtherPlayer = 1;

	GetPresetOptData( data.nPresetOption, data );
	
	data.nAllMute	    = 0;
	data.nBGM_Mute     = 0;
	data.nSFX_Mute     = 0;
	data.nENVS_Mute     = 0;
	data.nBGM_Volume   = 6; //0~9
	data.nSFX_Volume   = 8; //0~9
	data.nENVS_Volume   = 8; //0~9
	data.nMASTER_Volume   = 10; //0~9

}

void SGameOption::SetPlayDataDefault( _OPT_DATA& data )
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//	게임 플레이 관련 옵션
	data.nTABKey		= 0; //0~1	TAB키 설정

	std::string strCountry = ENV().GetString( "country" );
	if( strCountry == "<NULL>" )
		data.nEnterChat	= 0;
	else if( strCountry == "CN" )
		data.nEnterChat	= 1;
	else
		data.nEnterChat	= 0;

	data.nChipAttack	= 1; //0~1	포스칩 후 자동 공격
	data.nTrade			= 0; //0~1	거래 및 초대 거절
	data.nPVP			= 0; //0~1	대련신청_거부
	data.nAutoTarget	= 1; //0~1	// 공격_시_자동타겟팅
	data.nWheel			= 0; //0~1	휠방향_반전
	data.nChatHide		= 1; //0~1	체팅창 자동숨김
	data.nMobFace		= 0; //0~1	몬스?? 페이스컷
	data.nSimpleRak		= 1; //0~1	??인??점 아바타 표시
	data.nChatBalloon	= 1; //0~1	말풍선 표시
	data.nTip			= 1; //0~1	게임팁 표시
	// 2010.05.20 - prodongi
	//data.nHelm			= 1; //0~1	투구 보이기
	data.nMantle		= 1; //0~1	망토 보이기
	data.nHPGage		= 1; //0~1	체력게이지 표시
	data.nPlayerGage	= 1; //0~1	자신과 파티원
	data.nMobGage		= 1; //0~1	몬스터
	data.nTargetGage	= 1; //0~1	타겟
	data.nName			= 1; //0~1	이름 표시
	data.nPlayerName	= 1; //0~1	플레이어
	data.nCreatureName	= 1; //0~1	크리처
	data.nMobName		= 1; //0~1	몬스터
	data.nNPCName		= 1; //0~1	NPC
	data.ndamage		= 1; //0~1	데미?? 표시
	data.nPlayerDM		= 1; //0~1	자신
	data.nCreatureDM	= 1; //0~1	크리처
	data.nPartyDM		= 0; //0~1	파티원
	data.nWinLock		= 0; //0~1	현재윈도우장금
	data.nWinAlpha		= 0; //0~4	윈도우 투명도 설정
	data.nSelfBoothType	= 1; //0~3
	data.nCriticalCamera= 1; //0~1
//	data.nAvatarDeco    = 1; //0~1  // 2010.10.11. 게임플레이옵션에서 "꾸미기보이기" 제거.
	data.nWeatherQuality	= 3; //0~3
	data.nCameraCollision	= 1; //0~1
}

void SGameOption::GetDefPlayOptData(_OPT_DATA & data)
{
	data = m_curData;
	SetPlayDataDefault(data);
}

void SGameOption::SetUIPosDefault()
{
//	m_nQuickVerX;//	m_nQuickVerY;//	m_nQuickHozX;//	m_nQuickHozY;//	m_nVerticalQuick;
//	m_nStateVerX;//	m_nStateVerY;//	m_nStateHozX;//	m_nStateHozY;//	m_nVerticalState;
//	m_nMessangerOpen;
//	m_nCreatureOpen;
//	m_nChattingLine;//	m_nChattingHeight;

	//추가 2006/3/10 이동표
	m_nMessangerX	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Messanger][1];
	m_nMessangerY	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Messanger][2];

	m_nPartyX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Party][1];
	m_nPartyY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Party][2];

	m_nSysMenuX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::SysMenu][1];
	m_nSysMenuY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::SysMenu][2];

	m_nInventoryX	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Inventory][1];
	m_nInventoryY	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Inventory][2];


	m_nCreatureX	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Creature][1];
	m_nCreatureY	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Creature][2];

	m_nCreatureInfoX = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::CreatureInfo][1];
	m_nCreatureInfoY = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::CreatureInfo][2];

	m_nQuestX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Quest][1];
	m_nQuestY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Quest][2];

	m_nMotionX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Motion][1];
	m_nMotionY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Motion][2];

	m_nOptionX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Option][1];
	m_nOptionY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Option][2];

	m_nCharX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Char][1];
	m_nCharY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Char][2];

	m_nSkillX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Skill][1];
	m_nSkillY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Skill][2];

	m_nSystemX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::System][1];
	m_nSystemY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::System][2];

	m_nMapX			 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Map][1];
	m_nMapY			 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Map][2];

	m_nItemCombineX	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::ItemCombine][1];
	m_nItemCombineY	 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::ItemCombine][2];

	m_nShopX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Shop][1];
	m_nShopY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Shop][2];

	m_nStoreX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Store][1];
	m_nStoreY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Store][2];

	m_nStorageX		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Storage][1];
	m_nStorageY		 = SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Storage][2];

	m_nCreatureSkillX= SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::CreatureSkill][1];
	m_nCreatureSkillY= SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::CreatureSkill][2];

	// 장비창. bintitle. 2010.10.07.
	m_nPosEquipment.x= SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Equipment][1];
	m_nPosEquipment.y= SGAME_OPT_DATA::c_nWindowOption[SGAME_OPT_DATA::Equipment][2];
}

void SGameOption::SetCheckStr( bool * pCehck, char * pStr )
{
	char szCheckBuf[2];
	szCheckBuf[1] = '\0';

	if( ::_stricmp( pStr, "err" ) != 0 && ::strlen( pStr ) == SGAME_OPT_DATA::c_nMaxChatOption )
	{
		for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChatOption; i++ )
		{
			szCheckBuf[0] = pStr[i];
			pCehck[i] = !!( ::atoi( szCheckBuf ) );
		}
	}
}

void SGameOption::Load( const char* szName )
{
	// 로드 - 캐릭별 옵션
	if( strlen( szName ) <= 0 )	return;

	m_strName = szName;
	m_OptionManager.SetSection( szName );

	if( m_OptionManager.IsLoading() )
	{
		m_nMinimapAlpha = m_OptionManager.GetValueInt( "MINIMAP_ALPHA" );	//ENV().Bind( "opt.intf.MINIMAP_ALPHA", &m_nMinimapAlpha );
		if( m_nMinimapAlpha < MINIMAP_ALPHA_MIN || m_nMinimapAlpha > MINIMAP_ALPHA_MAX )	m_nMinimapAlpha = MINIMAP_ALPHA_MIDDLE;
		m_nMinimapOpen = ( m_OptionManager.GetValueInt( "MINIMAP_OPEN" ) == 0 ) ? 0 : 1;	ENV().Bind( "opt.intf.MINIMAP_OPEN", &m_nMinimapOpen );

		m_nFaceCut = m_OptionManager.GetValueInt( "INTERFACE_FACECUT" );	//ENV().Bind( "opt.intf.INTERFACE_FACECUT", &m_nFaceCut );
		if( m_nFaceCut > INTERFACE_LARGE || m_nFaceCut < INTERFACE_SMALL )		m_nFaceCut = INTERFACE_SMALL;
		m_nMinimap = m_OptionManager.GetValueInt( "INTERFACE_MINIMAP" );	//ENV().Bind( "opt.intf.INTERFACE_MINIMAP", &m_nMinimap );
		if( m_nMinimap > INTERFACE_LARGE || m_nMinimap < INTERFACE_SMALL )		m_nMinimap = INTERFACE_SMALL;
		m_nZoom = m_OptionManager.GetValueInt( "INTERFACE_ZOOM" );			//ENV().Bind( "opt.intf.INTERFACE_ZOOM", &m_nZoom );
		if( m_nZoom > INTERFACE_LARGE || m_nZoom < INTERFACE_SMALL )		m_nZoom = INTERFACE_SMALL;
	}

	// 인터페이스 옵션 ====================
	if( m_OptionManager.IsLoading() )
	{
		//m_nQuickVerX = m_OptionManager.GetValueInt( "QUICK_VER_X" );	//ENV().Bind( "opt.intf.QUICK_VER_X", &m_nQuickVerX );
		//m_nQuickVerY = m_OptionManager.GetValueInt( "QUICK_VER_Y" );	//ENV().Bind( "opt.intf.QUICK_VER_Y", &m_nQuickVerY );
		m_nQuickHozX = m_OptionManager.GetValueInt( "QUICK_HOZ_X" );	//ENV().Bind( "opt.intf.QUICK_HOZ_X", &m_nQuickHozX );
		m_nQuickHozY = m_OptionManager.GetValueInt( "QUICK_HOZ_Y" );	//ENV().Bind( "opt.intf.QUICK_HOZ_Y", &m_nQuickHozY );

		m_nVerticalQuick = ( m_OptionManager.GetValueInt( "QUICK_VER_OPEN" ) == 1 ) ? 1 : 0;	//ENV().Bind( "opt.intf.QUICK_VER_OPEN", &m_nVerticalQuick );

		//m_nStateVerX = m_OptionManager.GetValueInt( "STATE_VER_X" );	//ENV().Bind( "opt.intf.STATE_VER_X", &m_nStateVerX );
		//m_nStateVerY = m_OptionManager.GetValueInt( "STATE_VER_Y" );	//ENV().Bind( "opt.intf.STATE_VER_Y", &m_nStateVerY );
		m_nStateHozX = m_OptionManager.GetValueInt( "STATE_HOZ_X" );	//ENV().Bind( "opt.intf.STATE_HOZ_X", &m_nStateHozX );
		m_nStateHozY = m_OptionManager.GetValueInt( "STATE_HOZ_Y" );	//ENV().Bind( "opt.intf.STATE_HOZ_Y", &m_nStateHozY );

		m_nVerticalState = ( m_OptionManager.GetValueInt( "STATE_VER_OPEN" ) == 1 ) ? 1 : 0;	//ENV().Bind( "opt.intf.STATE_VER_OPEN", &m_nVerticalState );

		m_nMessangerX    = m_OptionManager.GetValueInt( "MESSANGER_X" );	//ENV().Bind( "opt.intf.MESSANGER_X", &m_nMessangerX );
		m_nMessangerY    = m_OptionManager.GetValueInt( "MESSANGER_Y" );	//ENV().Bind( "opt.intf.MESSANGER_Y", &m_nMessangerY );

		m_nMessangerOpen = m_OptionManager.GetValueInt( "MESSANGER_OPEN" );	//ENV().Bind( "opt.intf.MESSANGER_OPEN", &m_nMessangerOpen );

		m_nPartyX	    = m_OptionManager.GetValueInt( "PARTY_X" );
		m_nPartyY	    = m_OptionManager.GetValueInt( "PARTY_Y" );

		m_nCreatureOpen = ( m_OptionManager.GetValueInt( "CREAUTRE_OPEN" ) == 1 ) ? 1 : 0;	//ENV().Bind( "opt.intf.CREAUTRE_OPEN", &m_nCreatureOpen );

		m_nSysMenuX = m_OptionManager.GetValueInt( "SYSMENU_X" );	//ENV().Bind( "opt.intf.SYSMENU_X", &m_nSysMenuX );
		m_nSysMenuY = m_OptionManager.GetValueInt( "SYSMENU_Y" );	//ENV().Bind( "opt.intf.SYSMENU_Y", &m_nSysMenuY );

		m_nInventoryX = m_OptionManager.GetValueInt( "INVENTORY_X" );	//ENV().Bind( "opt.intf.INVENTORY_X", &m_nInventoryX );
		m_nInventoryY = m_OptionManager.GetValueInt( "INVENTORY_Y" );	//ENV().Bind( "opt.intf.INVENTORY_Y", &m_nInventoryY );

		m_nChattingLine   = m_OptionManager.GetValueInt( "CHATTING_LINE" );		//ENV().Bind( "opt.intf.CHATTING_LINE", &m_nChattingLine );
		m_nChattingHeight = m_OptionManager.GetValueInt( "CHATTING_HEIGHT" );	//ENV().Bind( "opt.intf.CHATTING_HEIGHT", &m_nChattingHeight );

		m_nCreatureX = m_OptionManager.GetValueInt( "CREATURE_X" );
		m_nCreatureY = m_OptionManager.GetValueInt( "CREATURE_Y" );

		m_nCreatureInfoX = m_OptionManager.GetValueInt( "CREATURE_INFO_X" );
		m_nCreatureInfoY = m_OptionManager.GetValueInt( "CREATURE_INFO_Y" );

		m_nQuestX = m_OptionManager.GetValueInt( "QUEST_X" );
		m_nQuestY = m_OptionManager.GetValueInt( "QUEST_Y" );

		m_nMotionX = m_OptionManager.GetValueInt( "MOTION_X" );
		m_nMotionY = m_OptionManager.GetValueInt( "MOTION_Y" );

		m_nOptionX = m_OptionManager.GetValueInt( "OPTION_X" );
		m_nOptionY = m_OptionManager.GetValueInt( "OPTION_Y" );

		m_nCharX = m_OptionManager.GetValueInt( "CHAR_X" );
		m_nCharY = m_OptionManager.GetValueInt( "CHAR_Y" );

		m_nSkillX = m_OptionManager.GetValueInt( "SKILL_X" );
		m_nSkillY = m_OptionManager.GetValueInt( "SKILL_Y" );

		m_nSystemX = m_OptionManager.GetValueInt( "SYSTEM_X" );
		m_nSystemY = m_OptionManager.GetValueInt( "SYSTEM_Y" );

		m_nMapX = m_OptionManager.GetValueInt( "MAP_X" );
		m_nMapY = m_OptionManager.GetValueInt( "MAP_Y" );

		m_nItemCombineX = m_OptionManager.GetValueInt( "ITEM_COMBINE_X" );
		m_nItemCombineY = m_OptionManager.GetValueInt( "ITEM_COMBINE_Y" );

		m_nShopX = m_OptionManager.GetValueInt( "SHOP_X" );
		m_nShopY = m_OptionManager.GetValueInt( "SHOP_Y" );

		m_nStoreX = m_OptionManager.GetValueInt( "STORE_X" );
		m_nStoreY = m_OptionManager.GetValueInt( "STORE_Y" );

		m_nStorageX = m_OptionManager.GetValueInt( "STORAGE_X" );
		m_nStorageY = m_OptionManager.GetValueInt( "STORAGE_Y" );

		m_nCreatureSkillX = m_OptionManager.GetValueInt( "CREATURESKILL_X" );
		m_nCreatureSkillY = m_OptionManager.GetValueInt( "CREATURESKILL_Y" );

		// 장비창 위치. bintitle. 2010.10.07.
		m_nPosEquipment.x = m_OptionManager.GetValueInt( "EQUIPMENT_X" );	
		m_nPosEquipment.y = m_OptionManager.GetValueInt( "EQUIPMENT_Y" );	

		m_bOpenEquipWnd = m_OptionManager.GetValueInt( "OPEN_EQUIP_WND_FLAG" );   //servantes 2010.11.02

		/// 2011.02.16 - prodongi
		m_useRechargeMsgBox = m_OptionManager.GetValueInt("USE_RECHARGE_MSGBOX");
		/// 2011.08.11 기본 값은 1로 설정 - prodongi
		if (-1 == m_useRechargeMsgBox)	
			m_useRechargeMsgBox = 1;
	}

	// 채팅
	if( m_OptionManager.IsLoading() )
	{
		char szBuf[256];	
		char szCheckBuf[2];
		// 채팅 옵션
		::memset( szBuf, 0, sizeof(szBuf) );
		szCheckBuf[1] = '\0';
		m_OptionManager.GetValueString( "CHAT_CHANNEL_00", szBuf );
		SetCheckStr( &m_bChannelCheck[0][0], szBuf );

		::memset( szBuf, 0, sizeof(szBuf) );
		m_OptionManager.GetValueString( "CHAT_CHANNEL_01", szBuf );
		SetCheckStr( &m_bChannelCheck[1][0], szBuf );

		::memset( szBuf, 0, sizeof(szBuf) );
		m_OptionManager.GetValueString( "CHAT_CHANNEL_02", szBuf );
		SetCheckStr( &m_bChannelCheck[2][0], szBuf );

		::memset( szBuf, 0, sizeof(szBuf) );
		m_OptionManager.GetValueString( "CHAT_CHANNEL_03", szBuf );
		SetCheckStr( &m_bChannelCheck[3][0], szBuf );

		::memset( szBuf, 0, sizeof(szBuf) );
		m_OptionManager.GetValueString( "CHAT_CHANNEL_04", szBuf );
		SetCheckStr( &m_bChannelCheck[4][0], szBuf );

		// 채널명
		char szTabName[64];
		::memset( szTabName, 0, sizeof(szTabName) );
		for( int i = 0; i < SGAME_OPT_DATA::c_nMaxChannel; i++ )
		{
			m_OptionManager.GetValueString( CStringUtil::StringFormat( "CHAT_TAB_NAME_%d", i ).c_str(), szTabName );
			if( ::_stricmp( szTabName, "err" ) != 0 )	m_strTabName[i] = szTabName;

			m_OptionManager.GetValueString( CStringUtil::StringFormat( "CHAT_TAB_MARK_%d", i ).c_str(), szTabName );
			if( ::_stricmp( szTabName, "err" ) != 0 )	m_strTabMark[i] = szTabName;
		}
	}
}
void SGameOption::SetMessengerType( int nType )
{
	m_nMessengerType = nType;
}

bool SGameOption::SetChatTabMark( int nIndex, const char* szTabMark )
{
	if( _stricmp( m_strTabMark[nIndex].c_str(), szTabMark ) == 0 ) return false; //같으면 리턴

	m_strTabMark[nIndex] = szTabMark;
	m_OptionManager.SetValueString( CStringUtil::StringFormat( "CHAT_TAB_MARK_%d", nIndex ).c_str(), m_strTabMark[nIndex].c_str() );

	return true;
}
const char* SGameOption::GetChatTabMark( int nIndex )
{
	return m_strTabMark[nIndex].c_str();
}

// 채널명
bool SGameOption::SetChatTabName( int nIndex, const char* szTabName )
{
	if( _stricmp( m_strTabName[nIndex].c_str(), szTabName ) == 0 ) return false; //같으면 리턴

	m_strTabName[nIndex] = szTabName;
	m_OptionManager.SetValueString( CStringUtil::StringFormat( "CHAT_TAB_NAME_%d", nIndex ).c_str(), m_strTabName[nIndex].c_str() );

	return true;
}
const char* SGameOption::GetChatTabName( int nIndex )
{
	return m_strTabName[nIndex].c_str();
}

//void SGameOption::SetQuickVerX( int nValue )			
//{
//	m_nQuickVerX		= nValue; 
//
//	m_OptionManager.SetValueInt( "QUICK_VER_X", m_nQuickVerX );
//}
//void SGameOption::SetQuickVerY( int nValue )			
//{
//	m_nQuickVerY		= nValue; 
//	
//	m_OptionManager.SetValueInt( "QUICK_VER_Y", m_nQuickVerY );
//}
void SGameOption::SetQuickHozX( int nValue )		
{
	m_nQuickHozX		= nValue; 

	m_OptionManager.SetValueInt( "QUICK_HOZ_X", m_nQuickHozX );
}
void SGameOption::SetQuickHozY( int nValue )			
{
	m_nQuickHozY		= nValue; 

	m_OptionManager.SetValueInt( "QUICK_HOZ_Y", m_nQuickHozY );
}
void SGameOption::SetVerticalQuick( int nVertical )	
{ 
	m_nVerticalQuick	= nVertical; 

	m_OptionManager.SetValueInt( "QUICK_VER_OPEN", m_nVerticalQuick );
}
//void SGameOption::SetStateVerX( int nValue )			
//{
//	m_nStateVerX		= nValue; 
//
//	m_OptionManager.SetValueInt( "STATE_VER_X", m_nStateVerX );
//}
//void SGameOption::SetStateVerY( int nValue )			
//{
//	m_nStateVerY		= nValue; 
//
//	m_OptionManager.SetValueInt( "STATE_VER_Y", m_nStateVerY );
//}
void SGameOption::SetStateHozX( int nValue )			
{
	m_nStateHozX		= nValue; 

	m_OptionManager.SetValueInt( "STATE_HOZ_X", m_nStateHozX );
}
void SGameOption::SetStateHozY( int nValue )			
{
	m_nStateHozY		= nValue; 

	m_OptionManager.SetValueInt( "STATE_HOZ_Y", m_nStateHozY );
}
void SGameOption::SetVerticalStat( int nVertical )	
{
	m_nVerticalState	= nVertical; 

	m_OptionManager.SetValueInt( "STATE_VER_OPEN", m_nVerticalState );
}
void SGameOption::SetMessangerX( int nValue )		
{
	m_nMessangerX		= nValue; 

	m_OptionManager.SetValueInt( "MESSANGER_X", m_nMessangerX );
};
void SGameOption::SetMessangerY( int nValue )	
{
	m_nMessangerY		= nValue; 

	m_OptionManager.SetValueInt( "MESSANGER_Y", m_nMessangerY );
}
void SGameOption::SetPartyX( int nValue )		
{
	m_nPartyX		= nValue; 

	m_OptionManager.SetValueInt( "PARTY_X", m_nPartyX );
};
void SGameOption::SetPartyY( int nValue )	
{
	m_nPartyY		= nValue; 

	m_OptionManager.SetValueInt( "PARTY_Y", m_nPartyY );
}
void SGameOption::SetMessangerOpep( int nOpen )		
{
	m_nMessangerOpen	= nOpen; 

	m_OptionManager.SetValueInt( "MESSANGER_OPEN", m_nMessangerOpen );
}
void SGameOption::SetCreatureOpen( int nOpen )		
{
	m_nCreatureOpen	= nOpen; 

	m_OptionManager.SetValueInt( "CREAUTRE_OPEN", m_nCreatureOpen );
}
void SGameOption::SetSysMenuX( int nValue )		
{
	m_nSysMenuX		= nValue; 

	m_OptionManager.SetValueInt( "SYSMENU_X", m_nSysMenuX );
}
void SGameOption::SetSysMenuY( int nValue )			
{
	m_nSysMenuY		= nValue; 

	m_OptionManager.SetValueInt( "SYSMENU_Y", m_nSysMenuY );
}
void SGameOption::SetCreatureSkillX( int nValue )
{
	m_nCreatureSkillX		= nValue; 

	m_OptionManager.SetValueInt( "CREATURESKILL_X", m_nCreatureSkillX );
}
void SGameOption::SetCreatureSkillY( int nValue )
{
	m_nCreatureSkillY		= nValue; 

	m_OptionManager.SetValueInt( "CREATURESKILL_Y", m_nCreatureSkillY );
}
void SGameOption::SetInventoryX( int nValue )	
{
	m_nInventoryX		= nValue; 

	m_OptionManager.SetValueInt( "INVENTORY_X", m_nInventoryX );
}
void SGameOption::SetInventoryY( int nValue )		
{
	m_nInventoryY		= nValue; 

	m_OptionManager.SetValueInt( "INVENTORY_Y", m_nInventoryY );
}
void SGameOption::SetChattingLine( int nValue )	
{
	m_nChattingLine	= nValue; 

	m_OptionManager.SetValueInt( "CHATTING_LINE", m_nChattingLine );
}
void SGameOption::SetChattingHeight( int nValue )
{
	m_nChattingHeight = nValue; 
	m_OptionManager.SetValueInt( "CHATTING_HEIGHT", m_nChattingHeight );
}
void SGameOption::SetCreatureX( int nValue )
{
	m_nCreatureX = nValue; 
	m_OptionManager.SetValueInt( "CREATURE_X", m_nCreatureX );
}
void SGameOption::SetCreatureY( int nValue )
{
	m_nCreatureY = nValue; 
	m_OptionManager.SetValueInt( "CREATURE_Y", m_nCreatureY );
}
void SGameOption::SetCreatureInfoX( int nValue )
{
	m_nCreatureInfoX = nValue; 
	m_OptionManager.SetValueInt( "CREATURE_INFO_X", m_nCreatureInfoX );
}
void SGameOption::SetCreatureInfoY( int nValue )
{
	m_nCreatureInfoY = nValue; 
	m_OptionManager.SetValueInt( "CREATURE_INFO_Y", m_nCreatureInfoY );
}
void SGameOption::SetQuestX( int nValue )
{
	m_nQuestX = nValue; 
	m_OptionManager.SetValueInt( "QUEST_X", m_nQuestX );
}
void SGameOption::SetQuestY( int nValue )
{
	m_nQuestY = nValue; 
	m_OptionManager.SetValueInt( "QUEST_Y", m_nQuestY );
}
void SGameOption::SetMotionX( int nValue )
{
	m_nMotionX = nValue; 
	m_OptionManager.SetValueInt( "MOTION_X", m_nMotionX );
}
void SGameOption::SetMotionY( int nValue )
{
	m_nMotionY = nValue; 
	m_OptionManager.SetValueInt( "MOTION_Y", m_nMotionY );
}
void SGameOption::SetOptionX( int nValue )
{
	m_nOptionX = nValue; 
	m_OptionManager.SetValueInt( "OPTION_X", m_nOptionX );
}
void SGameOption::SetOptionY( int nValue )
{
	m_nOptionY = nValue; 
	m_OptionManager.SetValueInt( "OPTION_Y", m_nOptionY );
}
void SGameOption::SetCharX( int nValue )
{
	m_nCharX = nValue; 
	m_OptionManager.SetValueInt( "CHAR_X", m_nCharX );
}
void SGameOption::SetCharY( int nValue )
{
	m_nCharY = nValue; 
	m_OptionManager.SetValueInt( "CHAR_Y", m_nCharY );
}
void SGameOption::SetSkillX( int nValue )
{
	m_nSkillX = nValue; 
	m_OptionManager.SetValueInt( "SKILL_X", m_nSkillX );
}
void SGameOption::SetSkillY( int nValue )
{
	m_nSkillY = nValue; 
	m_OptionManager.SetValueInt( "SKILL_Y", m_nSkillY );
}
void SGameOption::SetSystemX( int nValue )
{
	m_nSystemX = nValue; 
	m_OptionManager.SetValueInt( "SYSTEM_X", m_nSystemX );
}
void SGameOption::SetSystemY( int nValue )
{
	m_nSystemY = nValue; 
	m_OptionManager.SetValueInt( "SYSTEM_Y", m_nSystemY );
}
void SGameOption::SetMapX( int nValue )
{
	m_nMapX = nValue; 
	m_OptionManager.SetValueInt( "MAP_X", m_nMapX );
}
void SGameOption::SetMapY( int nValue )
{
	m_nMapY = nValue; 
	m_OptionManager.SetValueInt( "MAP_Y", m_nMapY );
}
void SGameOption::SetItemCombineX( int nValue )
{
	m_nItemCombineX = nValue; 
	m_OptionManager.SetValueInt( "ITEM_COMBINE_X", m_nItemCombineX );
}
void SGameOption::SetItemCombineY( int nValue )
{
	m_nItemCombineY = nValue; 
	m_OptionManager.SetValueInt( "ITEM_COMBINE_Y", m_nItemCombineY );
}
void SGameOption::SetShopX( int nValue )
{
	m_nShopX = nValue; 
	m_OptionManager.SetValueInt( "SHOP_X", m_nShopX );
}
void SGameOption::SetShopY( int nValue )
{
	m_nShopY = nValue; 
	m_OptionManager.SetValueInt( "SHOP_Y", m_nShopY );
}
void SGameOption::SetStoreX( int nValue )
{
	m_nStoreX = nValue; 
	m_OptionManager.SetValueInt( "STORE_X", m_nStoreX );
}
void SGameOption::SetStoreY( int nValue )
{
	m_nStoreY = nValue; 
	m_OptionManager.SetValueInt( "STORE_Y", m_nStoreY );
}
void SGameOption::SetStorageX( int nValue )
{
	m_nStorageX = nValue; 
	m_OptionManager.SetValueInt( "STORAGE_X", m_nStorageX );
}
void SGameOption::SetStorageY( int nValue )
{
	m_nStorageY = nValue; 
	m_OptionManager.SetValueInt( "STORAGE_Y", m_nStorageY );
}


void SGameOption::SetEquipmentWndPos( KPoint & point )
{
	m_nPosEquipment = point; 
	m_OptionManager.SetValueInt( "EQUIPMENT_X", m_nPosEquipment.x );
	m_OptionManager.SetValueInt( "EQUIPMENT_Y", m_nPosEquipment.y );
}

void SGameOption::SetOpenEquipWnd(bool nValue) //servantes 2010.11.02
{
	m_bOpenEquipWnd = nValue; 
	m_OptionManager.SetValueInt( "OPEN_EQUIP_WND_FLAG", m_bOpenEquipWnd );
}

/// 2011.02.16 - prodongi
void SGameOption::SetUseRechargeMsgBox(bool use)
{
	m_useRechargeMsgBox = use ? 1 : 0;
	m_OptionManager.SetValueInt("USE_RECHARGE_MSGBOX", m_useRechargeMsgBox);
}

bool SGameOption::NotifyTitle(int changeOpt)
{
	static int beforeOpt = -1;

	if(beforeOpt != changeOpt)		// 옵션이 바뀌였다면..
	{
		beforeOpt = changeOpt;
		return true;
	}
	else
		return false;
}

bool SGameOption::IsChatOptionCheck( int nTabMode, int nIndex )
{
	if( nIndex < 0 || nIndex > SGAME_OPT_DATA::c_nMaxChatOption ) return false;

	switch(nTabMode)
	{
	case 0:	return m_bChannelCheck[nTabMode][nIndex];
	case 1:	return m_bChannelCheck[nTabMode][nIndex];
	case 2:	return m_bChannelCheck[nTabMode][nIndex];
	case 3:	return m_bChannelCheck[nTabMode][nIndex];
	case 4:	return m_bChannelCheck[nTabMode][nIndex];

	}
	return false;
}

void SGameOption::SettingForMinimumSystem()
{
	SetResourceQuality( 0 );
	SetTextureMipBias( 0 );
	SetLight( 0 );
	SetWaterQuality( 0 );
	SetLowShadow( 1 );
	SetShadow( 1 );
}

void SGameOption::SettingForMaximumSystem()
{
	SetResourceQuality( 1 );
	SetTextureMipBias( 2 );
}

SGameOption & GetGameOption()
{
	static SGameOption gameoption;
	return gameoption;
}

//////////////////////////////////////////////////////////////////////////
// INI file
//////////////////////////////////////////////////////////////////////////

SINIManager::SINIManager()
{
	m_strFile.clear();

	m_strGlobalSection = "RAPPELZ";
}
SINIManager::~SINIManager()
{
}

bool SINIManager::LoadOptionFilePath( const char* szFilePath )
{
	m_strFile=szFilePath;
	FILE * pF = fopen( szFilePath, "rb" );
	if( pF )
	{
		fclose( pF );
		return true;
	}

	return false;
}

bool SINIManager::LoadOptionFile( const char* szFileName )
{
	char pBuf[MAX_PATH];
	GetCurrentDirectory( MAX_PATH, pBuf );
	m_strFile = pBuf;
	m_strFile += szFileName;
	
	FILE * pF = fopen( m_strFile.c_str(), "rb" );
	if( pF )
	{
		fclose( pF );
		return true;
	}

	return false;
}
bool SINIManager::SetValueInt( std::string strKey, int nValue, bool bGlobal )
{
	if( m_strFile.size() <= 0 )		return false;
	
	std::string strSection = m_strSection;
	if( bGlobal )	strSection = m_strGlobalSection;
	else
	{	//섹션이 없을 경우, Save 하지 않는다.
		if( m_strSection.length() <= 0 ) return false;
	}
	
	std::string strValue = CStringUtil::StringFormat( "%d", nValue );

	return !!(WritePrivateProfileString( strSection.c_str(), strKey.c_str(), strValue.c_str(), m_strFile.c_str() ));
}
int SINIManager::GetValueInt( std::string strKey, bool bGlobal )
{
	if( m_strFile.size() <= 0 )		return ERR_RESULT;

	std::string strSection = m_strSection;
	if( bGlobal )	strSection = m_strGlobalSection;

	return GetPrivateProfileInt( strSection.c_str(), strKey.c_str(), ERR_RESULT, m_strFile.c_str() );
}

bool SINIManager::SetValueString( std::string strKey, std::string strValue, bool bGlobal )
{
	if( m_strFile.size() <= 0 )		return false;

	std::string strSection = m_strSection;
	if( bGlobal )	strSection = m_strGlobalSection;
	else
	{	//섹션이 없을 경우, Save 하지 않는다.
		if( m_strSection.length() <= 0 ) return false;
	}

	std::string strEnvKey = "opt.";
	strEnvKey += strKey;
	//ENV().Set( strEnvKey.c_str(), strValue.c_str() );

	return !!(WritePrivateProfileString( strSection.c_str(), strKey.c_str(), strValue.c_str(), m_strFile.c_str() ));
}

void SINIManager::GetValueString( std::string strKey, char* szBuf, bool bGlobal )
{
	if( m_strFile.size() <= 0 )	
	{
		szBuf = "err";
		return;
	}

	std::string strSection = m_strSection;
	if( bGlobal )	strSection = m_strGlobalSection;

	GetPrivateProfileString( strSection.c_str(), strKey.c_str(), "err", szBuf, 255, m_strFile.c_str() );

	//std::string strEnvKey = "opt.";
	//strEnvKey += strKey;
	//ENV().Set( strEnvKey.c_str(), szBuf );
}





SLocaleOption::SLocaleOption()
{
}



SLocaleOption::~SLocaleOption()
{
}


void SLocaleOption::LoadValueString(const char *key)
{
	char szTemp[512];
	::memset( szTemp, 0, sizeof(szTemp) );
	
	m_OptionManager.GetValueString(key, szTemp, true );
	if( ::_stricmp( szTemp, "err" ) != 0 )	
	{
		strlwr(szTemp);
		m_StrMap[key] = szTemp;
	}
}


void SLocaleOption::LoadValueInt(const char *key)
{
	int d = m_OptionManager.GetValueInt( key, true );
	if( ERR_RESULT !=  d)
		m_IntMap[key] = d;	
}


// 2010.06.29 - prodongi
bool SLocaleOption::pickupValue(char const* data, char const* startToken, char endToken, char* value)
{
	size_t size, i;

	// start
	char const* f_start = strstr(data, startToken);
	if (!f_start)
		return false;
	++f_start;

	// 공백 제거
	size = strlen(f_start);
	for (i = 0; i < size; ++i)
	{
		if (*f_start != ' ')
			break;
		++f_start;
	}

	// end
	char const* f_end = NULL;
	size = strlen(f_start);
	for (i = 0; i < size; ++i)
	{
		if (f_start[i] == endToken)
		{
			f_end = f_start + i - 1;
			break;
		}
	}
	if (i == size)
		f_end = f_start + i;
	if (!f_end)
		return false;

	size = f_end - f_start;
	strncpy(value, f_start, size);
	value[size] = 0x00;

	// 공백 제거
	for (i = size-1; i > 0; --i)
	{
		if (value[i] != ' ')
		{
			value[i+1] = 0x00;
			break;
		}
	}

	return true;
}

// 2010.06.29 - prodongi
void SLocaleOption::parsingValueString(char const* key, char const* data, char* value)
{
	if (!parsingValue(key, data, value))
		return ;

	strlwr(value);
	m_StrMap[key] = value;
	_oprint("%s=%s\n", key, value);
}

// 2010.06.29 - prodongi
void SLocaleOption::parsingValueInt(char const* key, char const* data, char* value)
{
	if (!parsingValue(key, data, value))
		return ;
	m_IntMap[key] = atoi(value);
	_oprint("%s=%s\n", key, value);
}

// 2010.06.29 - prodongi
bool SLocaleOption::parsingValue(char const* key, char const* data, char* value)
{
	char const* f = strstr(data, key);
	if (!f)
		return false;

	return pickupValue(f, "=", '\n', value);
}

// 2010.09.01 - prodongi
void SLocaleOption::parsingBigSmallValueString(char const* bigKey, char const* smallKey, char const* parsingData, char* value)
{
	parsingValueString(bigKey, parsingData, value);
	if (isValue(m_StrMap, bigKey))	copyValue(m_StrMap,bigKey, smallKey);
	else
	{
		parsingValueString(smallKey, parsingData, value);
		if (isValue(m_StrMap, smallKey))	copyValue(m_StrMap, smallKey, bigKey);
	}
}

// 2010.09.01 - prodongi
void SLocaleOption::parsingBigSmallValueInt(char const* bigKey, char const* smallKey, char const* parsingData, char* value)
{
	parsingValueInt(bigKey, parsingData, value);
	if (isValue(m_IntMap, bigKey))	copyValue(m_IntMap,bigKey, smallKey);
	else
	{
		parsingValueInt(smallKey, parsingData, value);
		if (isValue(m_IntMap, smallKey))	copyValue(m_IntMap, smallKey, bigKey);
	}
}

// 2010.06.29 - prodongi
bool SLocaleOption::parsingOptionFile(const char* filename)
{
	char* data = KFileManager::Instance().readData(filename);
	if (!data)
		return false;

	volatile int CurrentLocalBitset = GameRule::GetCurrentLocalBitSet();


	m_OptionManager.m_strGlobalSection = "[RAPPELZ]";

	if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::KR)			m_OptionManager.m_strGlobalSection = "[RAPPELZ_KR]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::HK)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_HK]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::US)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_US]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::DE)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_DE]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::JP)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_JP]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::TW)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_TW]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::CN)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_CN]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::FR)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_FR]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::RU)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_RU]";
	// 2010.06.14 - prodongi
	//else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::MA)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_MA]";
	//else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::SG)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_SG]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::MASG)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_MASG]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::PH)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_PH]";

	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::VN)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_VN]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::TL)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_TL]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::ME)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_ME]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::TR)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_TR]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::PL)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_PL]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::IT)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_IT]";
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::BR)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_BR]";	// 2010.09.08 브라질 - prodongi
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::ES)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_ES]";	// 2011.03.17 스페인 - prodongi
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::ID)	m_OptionManager.m_strGlobalSection = "[RAPPELZ_ID]";	// 2011.07.21 인도네시아 - prodongi

	m_StrMap.clear();
	m_IntMap.clear();

	char* parsingData = new char[strlen(data)];
	if (!pickupValue(data, m_OptionManager.m_strGlobalSection.c_str(), '[', parsingData))
	{
		delete[] data;
		delete[] parsingData;
		return false;
	}

	char value[512];

	parsingValueString("PUBLISHER_LOGO", parsingData, value);
	parsingValueString("PUBLISHER_LOGO_BGM", parsingData, value);		
	parsingValueString("NFLAVOR_LOGO", parsingData, value);		
	parsingValueString("NFLAVOR_LOGO_BGM", parsingData, value);
	parsingValueString("PUBLISHER2nd_LOGO", parsingData, value);
	parsingValueString("PUBLISHER2nd_LOGO_BGM", parsingData, value);		
	parsingValueString("COPYRIGHT", parsingData, value);
	parsingValueString("COPYRIGHT_BGM", parsingData, value);	

	parsingValueString("PUBLISHER_LOGO_DRAWMODE", parsingData, value);
	parsingValueString("NFLAVOR_LOGO_DRAWMODE", parsingData, value);
	parsingValueString("PUBLISHER2nd_LOGO_DRAWMODE", parsingData, value);
	parsingValueString("COPYRIGHT_DRAWMODE", parsingData, value);

	parsingValueString("GAME_INTRO", parsingData, value);
	parsingValueString("GAME_INTRO_BGM", parsingData, value);
	parsingValueString("GAME_INTRO_DRAWMODE", parsingData, value);

	parsingValueString("LOGIN_RAPPELZ_LOGO", parsingData, value);
	parsingValueString("LOGIN_RAPPELZ_SUBTITLE", parsingData, value);
	parsingValueString("LOGIN_PUBLISHER_LOGO", parsingData, value);
	parsingValueString("LOGIN_NFLAVOR_LOGO", parsingData, value);

	parsingValueString("LOADING_PUBLISHER_LOGO", parsingData, value);
	parsingValueString("LOADING_NFLAVOR_LOGO", parsingData, value);
	parsingValueString("LOADING_RAPPELZ_LOGO", parsingData, value);		
	parsingValueString("LOADING_UPINFO_NUI", parsingData, value);
	parsingValueString("LOADING_DOWNINFO_NUI", parsingData, value);

	parsingValueString("ENDING_PUBLISHER_LOGO", parsingData, value);
	parsingValueString("ENDING_NFLAVOR_LOGO", parsingData, value);		
	parsingValueString("ENDING_DOWNINFO_NUI", parsingData, value);

	parsingValueString("IDPW_URL", parsingData, value);
	parsingValueString("JOIN_URL", parsingData, value);
	parsingValueString("SECURITY_URL", parsingData, value);
	//parsingValueString( "SECURITY_EMAIL" );

	parsingValueString("NOTICE_URL", parsingData, value);
	parsingValueInt("CODEPAGE", parsingData, value);
	parsingValueString("FONT", parsingData, value);

	// 2010.09.01 대문자로 표기되야 되나, 만약 소문자로 표기된 경우를 고려 - prodongi
	/*
	// 이 아래 폰트 관련 값들 읽어 놓는거 해놔야 되는데 안한거 같음.. floyd 2010. 6. 24
	parsingValueString("font_default", parsingData, value);
	parsingValueString("font_01", parsingData, value);
	parsingValueString("font_02", parsingData, value);

	parsingValueInt("font_default_hinting", parsingData, value);
	parsingValueInt("font_01_hinting", parsingData, value);
	parsingValueInt("font_02_hinting", parsingData, value);
	*/
	parsingBigSmallValueString("FONT_DEFAULT", "font_default", parsingData, value);
	parsingBigSmallValueString("FONT_01", "font_01", parsingData, value);
	parsingBigSmallValueString("FONT_02", "font_02", parsingData, value);
	parsingBigSmallValueString("FONT_03", "font_03", parsingData, value);

	parsingBigSmallValueInt("FONT_DEFAULT_HINTING", "font_default_hinting", parsingData, value);
	parsingBigSmallValueInt("FONT_01_HINTING", "font_01_hinting", parsingData, value);
	parsingBigSmallValueInt("FONT_02_HINTING", "font_02_hinting", parsingData, value);
	parsingBigSmallValueInt("FONT_03_HINTING", "font_03_hinting", parsingData, value);

	SetExceptionalCodePage();

	SLOG("Locale File - %s\n", m_OptionManager.m_strGlobalSection.c_str() );
	delete[] data;
	delete[] parsingData;

	return true;
}

bool SLocaleOption::LoadOptionFile(const char *filename)
{
	std::string strFile = KFileManager::Instance().CreateTemporaryFileFromResourceWithLocale( filename );
	if( strFile.empty() )
		return false;

	m_OptionManager.m_strGlobalSection = "RAPPELZ";

	if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::KR)			m_OptionManager.m_strGlobalSection = "RAPPELZ_KR";	// Korea
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::HK)	m_OptionManager.m_strGlobalSection = "RAPPELZ_HK";	// Hong Kong (Traditional Chinese)
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::US)	m_OptionManager.m_strGlobalSection = "RAPPELZ_US";	// United States
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::DE)	m_OptionManager.m_strGlobalSection = "RAPPELZ_DE";	// Germany
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::JP)	m_OptionManager.m_strGlobalSection = "RAPPELZ_JP";	// Japan
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::TW)	m_OptionManager.m_strGlobalSection = "RAPPELZ_TW";	// Taiwan
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::CN)	m_OptionManager.m_strGlobalSection = "RAPPELZ_CN";	// China
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::FR)	m_OptionManager.m_strGlobalSection = "RAPPELZ_FR";	// France
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::RU)	m_OptionManager.m_strGlobalSection = "RAPPELZ_RU";	// Russia

	//else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::MA)	m_OptionManager.m_strGlobalSection = "RAPPELZ_MA";	//
	//else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::SG)	m_OptionManager.m_strGlobalSection = "RAPPELZ_SG";	//
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::MASG)	m_OptionManager.m_strGlobalSection = "RAPPELZ_MASG";// Malaysia (Singapore)
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::PH)	m_OptionManager.m_strGlobalSection = "RAPPELZ_PH";	// Philippines

	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::VN)	m_OptionManager.m_strGlobalSection = "RAPPELZ_VN";	//
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::TL)	m_OptionManager.m_strGlobalSection = "RAPPELZ_TL";	// 
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::ME)	m_OptionManager.m_strGlobalSection = "RAPPELZ_ME";	// Middle Earth (Arabic)
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::TR)	m_OptionManager.m_strGlobalSection = "RAPPELZ_TR";	// Turkey
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::PL)	m_OptionManager.m_strGlobalSection = "RAPPELZ_PL";	// Poland
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::IT)	m_OptionManager.m_strGlobalSection = "RAPPELZ_IT";	// Italy
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::BR)	m_OptionManager.m_strGlobalSection = "RAPPELZ_BR";	// Brazil
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::ES)	m_OptionManager.m_strGlobalSection = "RAPPELZ_ES";	// Spain
	else if(GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::ID)	m_OptionManager.m_strGlobalSection = "RAPPELZ_ID";	// Indonesia
		
	if(m_OptionManager.LoadOptionFilePath(strFile.c_str() ))
	{
	
		m_StrMap.clear();
		m_IntMap.clear();

		LoadValueString( "PUBLISHER_LOGO" );
		LoadValueString( "PUBLISHER_LOGO_BGM" );		
		LoadValueString( "NFLAVOR_LOGO" );		
		LoadValueString( "NFLAVOR_LOGO_BGM" );
		LoadValueString( "PUBLISHER2nd_LOGO" );
		LoadValueString( "PUBLISHER2nd_LOGO_BGM" );		
		LoadValueString( "COPYRIGHT" );
		LoadValueString( "COPYRIGHT_BGM" );	

		LoadValueString( "PUBLISHER_LOGO_DRAWMODE" );
		LoadValueString( "NFLAVOR_LOGO_DRAWMODE" );
		LoadValueString( "PUBLISHER2nd_LOGO_DRAWMODE" );
		LoadValueString( "COPYRIGHT_DRAWMODE" );
	
		LoadValueString( "GAME_INTRO" );
		LoadValueString( "GAME_INTRO_BGM" );
		LoadValueString( "GAME_INTRO_DRAWMODE" );

		LoadValueString( "LOGIN_RAPPELZ_LOGO" );
		LoadValueString( "LOGIN_RAPPELZ_SUBTITLE" );
		LoadValueString( "LOGIN_PUBLISHER_LOGO" );
		LoadValueString( "LOGIN_NFLAVOR_LOGO" );

		LoadValueString( "LOADING_PUBLISHER_LOGO" );
		LoadValueString( "LOADING_NFLAVOR_LOGO" );
		LoadValueString( "LOADING_RAPPELZ_LOGO" );		
		LoadValueString( "LOADING_UPINFO_NUI" );
		LoadValueString( "LOADING_DOWNINFO_NUI" );

		LoadValueString( "ENDING_PUBLISHER_LOGO" );
		LoadValueString( "ENDING_NFLAVOR_LOGO" );		
		LoadValueString( "ENDING_DOWNINFO_NUI" );

		LoadValueString( "IDPW_URL" );
		LoadValueString( "JOIN_URL" );
		LoadValueString( "SECURITY_URL" );

		LoadValueString( "NOTICE_URL" );
		LoadValueInt( "CODEPAGE" );
		LoadValueString( "FONT" );

		// 2010.08.26 - prodongi
		/*
		// 이 아래 폰트 관련 값들 읽어 놓는거 해놔야 되는데 안한거 같음.. floyd 2010. 6. 24
		LoadValueString( "font_default" );
		LoadValueString( "font_01" );
		LoadValueString( "font_02" );

		LoadValueInt( "font_default_hinting" );
		LoadValueInt( "font_01_hinting" );
		LoadValueInt( "font_02_hinting" );
		*/
		LoadValueString( "FONT_DEFAULT" );
		LoadValueString( "FONT_01" );
		LoadValueString( "FONT_02" );
		LoadValueString( "FONT_03" );

		LoadValueInt( "FONT_DEFAULT_HINTING" );
		LoadValueInt( "FONT_01_HINTING" );
		LoadValueInt( "FONT_02_HINTING" );
		LoadValueInt( "FONT_03_HINTING" );

		// nui 파일에서는 FONT_DEFAULT, FONT_01, FONT_02가 소문자로 설정되기 때문에,
		// 소문자도 수동으로 추가해준다
		copyValue(m_StrMap, "FONT_DEFAULT", "font_default");
		copyValue(m_StrMap, "FONT_01", "font_01");
		copyValue(m_StrMap, "FONT_02", "font_02");
		copyValue(m_StrMap, "FONT_03", "font_03");


		/*LoadValueString( "USERSCREENSHOT_URL" );

		LoadValueString( "INGAME_HELP_URL" );
		LoadValueInt( "INGAME_HELP_WIDTH" );
		LoadValueInt( "INGAME_HELP_HEIGHT" );

		LoadValueString( "INGAME_STORE_URL" );
		LoadValueInt( "INGAME_STORE_WIDTH" );
		LoadValueInt( "INGAME_STORE_HEIGHT" );

		LoadValueString( "INGAME_STORE_ADD_URL" );
		LoadValueInt( "INGAME_STORE_ADD_WIDTH" );
		LoadValueInt( "INGAME_STORE_ADD_HEIGHT" );*/

		// 2010.06.29 중복 코드라서 주석처리 함 - prodongi
		// 2010.06.25 - prodongi
		/*
		LoadValueString("font_01");
		LoadValueString("font_02");
		LoadValueString("font_default");
		LoadValueInt("font_01_hinting");
		LoadValueInt("font_02_hinting");
		LoadValueInt("font_default_hinting");
		*/

		SetExceptionalCodePage();

		SLOG("Locale File - %s\n", m_OptionManager.m_strGlobalSection.c_str() );
		return true;
	}
	else
	{
		SLOG("Locale File - not Read\n");
		return false;		
	}
}



int	SLocaleOption::GetValueInt( std::string strKey, int bDefaultValue)
{
	if(m_IntMap.find( strKey) == m_IntMap.end() )
		return bDefaultValue;
	else 
		return m_IntMap[strKey];
}


const char *SLocaleOption::GetValueString( std::string strKey, const char *defaultstr)
{
	if(m_StrMap.find( strKey) == m_StrMap.end() )
		return defaultstr;
	else 
		return m_StrMap[strKey].c_str();
}

void	SLocaleOption::SetExceptionalCodePage()
{
	// 동남아의 번체 중국어 설정
	if( GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::MASG )
	{
		if( stricmp( ENV().GetString( "locale" ).c_str(), "BIG5" ) == 0 )
		{
			// Change in UTF-8 950 65001
			m_IntMap["CODEPAGE"] = 950;
		}
	}

	if( GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::IT ||	// Italy
		GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::PL ||	// Poland
		GameRule::GetCurrentLocalBitSet() == GameRule::LOCAL_BITSET::TR )	// Turkey
	{
		// Italian:	Windows-1252
		// Polish:	Windows-1250
		// Turkish:	Windows-1254
		// English:	ASCII
		if( stricmp( ENV().GetString( "locale" ).c_str(), "windows-1252" ) == 0 )
		{
			// Change in UTF-8 1252 65001
			m_IntMap["CODEPAGE"] = 1252;
		}
		else if( stricmp( ENV().GetString( "locale" ).c_str(), "windows-1250" ) == 0 )
		{
			// Change in UTF-8 1250
			m_IntMap["CODEPAGE"] = 1250;
		}
		else if( stricmp( ENV().GetString( "locale" ).c_str(), "windows-1254" ) == 0 )
		{
			// Change in UTF-8 1254
			m_IntMap["CODEPAGE"] = 1254;
		}
		else if( stricmp( ENV().GetString( "locale" ).c_str(), "ASCII" ) == 0 )
		{
			// Change in UTF-8 1252
			m_IntMap["CODEPAGE"] = 1252;
		}
	}
}


SLocaleOption  &GetLocaleOption()
{
	static SLocaleOption  localeoption;
	return localeoption;
}