#pragma once

//#include <string>
//#include <vector>
#include <mmo/ArType.h>
#include <toolkit/c_hidint.h>

#include "SGameUIMgr.h"

namespace 
{
	typedef std::vector<std::string>		STR_LIST;
}



// 추가 2010.04.13  bintitle.
//enum _PERMIT_REQUIRED_ACTION
//{
//    PRA_PERMISSION_MANAGEMENT            = 1 << 0,    // 길드 권한 관리
//    PRA_MEMBER_MANAGEMENT                = 1 << 1,    // 길드원 가입과 제외
//    PRA_GRANT_REVOKE_PERMISSION          = 1 << 2,    // 길드원 승급/강등
//    PRA_DUNGEON_MANAGEMENT               = 1 << 3,    // 던전 관리
//    PRA_REQUEST_DUNGEON_RAID             = 1 << 4,    // 던전 레이드 신청
//    PRA_ATTACK_TEAM_CREATE               = 1 << 5,    // 공격대 결성
//    PRA_ATTACK_TEAM_JOIN                 = 1 << 6,    // 공격대 참가
//    PRA_NOTICE                           = 1 << 7,    // 길드 공지
//    PRA_MEMBER_MEMO                      = 1 << 8,    // 길드원 메모 작성/수정
//    PRA_ALLIANCE_MANAGEMENT              = 1 << 9,    // 길드 연합 관리(마스터 길드용)
//    PRA_ALLIANCE_JOIN                    = 1 << 10,   // 길드 연합 가입(길마 대행 연합 가입)
//    PRA_ALLIANCE_LEAVE                   = 1 << 11,   // 길드 연합 탈퇴(길마 대행 연합 탈퇴)
//    PRA_SET_GUILD_ICON                   = 1 << 12,   // 길드 아이콘 설정
//};

enum _PERMISSION
{
        PERMISSION_NONE         = 0,  // 권한 없음(길드 소속이 아니거나 권한 정보가 부여되지 않은 경우)

        PERMISSION_MEMBER_LEAST = 1,  // 길드 멤버 권한 중 최소 권한
        PERMISSION_MEMBER_MAX   = 6,  // 길드 멤버 권한 중 최대 권한
        PERMISSION_LEADER       = 7,  // 길드장 권한
};


enum _PERMIT_REQUIRED_ACTION
{
        // PRA_PERMISSION_MANAGEMENT             = 1 << 0,      // 길드 권한 관리
		PRA_SET_PERMISSION_NAME				  = 1 << 0,		 // 길드등급명쓰기 
        PRA_MEMBER_INVITE                     = 1 << 1,      // 길드원 초대
        PRA_MEMBER_KICK                       = 1 << 2,      // 길드원 추방
        PRA_GRANT_REVOKE_PERMISSION           = 1 << 3,      // 길드원 승급/강등
        PRA_DUNGEON_MANAGEMENT                = 1 << 4,      // 던전 관리
        PRA_REQUEST_DUNGEON_RAID              = 1 << 5,      // 던전 레이드 신청
        PRA_ATTACK_TEAM_CREATE                = 1 << 6,      // 공격대 결성
        PRA_ATTACK_TEAM_JOIN                  = 1 << 7,      // 공격대 참가
        PRA_NOTICE                            = 1 << 8,      // 길드 공지
        PRA_MEMBER_MEMO                       = 1 << 9,      // 길드원 메모 작성/수정
        PRA_ALLIANCE_MANAGEMENT               = 1 << 10,     // 길드 연합 관리(마스터 길드용)
        PRA_ALLIANCE_JOIN                     = 1 << 11,     // 길드 연합 가입(길마 대행 연합 가입)
        PRA_ALLIANCE_LEAVE                    = 1 << 12,     // 길드 연합 탈퇴(길마 대행 연합 탈퇴)
        PRA_UPDATE_GUILD_ICON                 = 1 << 13,     // 길드 아이콘 변경
        PRA_ADVERTISE_MANAGEMENT              = 1 << 14,     // 길드 광고 관리

		//// 우선 임의로 한다. TEST. 등급별권한설정 은 업데이트에서 제외됐다.
		// PRA_WRITECLASSNAME					  = 1 << 15,     // 등급명칭쓰기
		//PRA_CLASS_AUTHORITY_SET               = 1 << 16,     // 등급별권한설정
};



// 추가 2010.04.13  bintitle.
// 연합길드 정보.
struct SAllianceGuild
{
	// 연합길드정보 //
	static int nAllianceID;				// 연합SID
	static std::string strAllianceName; // 연합명
	static int nAllianceMemberCount;	// 연합길드 맴버수.
	static int nAllianceMasterGuildSID; // 연합장 길드 SID
	static std::string strAllianceLeaderName; // 연합장 이름.
	
	int nID;					// 길드SID	
	std::string strName;		// 길드명
	std::string strLeaderName;	// 길드장명
	int nMemberCount;			// 길드원수

	SAllianceGuild( int _nID, std::string & _strName, std::string & _strLeaderName, int _nMemberCount )
		: nID( _nID ), strName( _strName ), strLeaderName( _strLeaderName ), nMemberCount( _nMemberCount )
	{}

	//SAllianceGuild( int _nAllianceID, std::string & _strAllianceName, int _nAllianceMemberCount, int _nAllianceMasterGuildSID,
	//				int _nID, std::string & _strName, std::string & _strLeaderName, int _nMemberCount )
	//	: nAllianceID( _nAllianceID ), strAllianceName( _strAllianceName ), nAllianceMemberCount( _nAllianceMemberCount ), nAllianceMasterGuildSID( _nAllianceMasterGuildSID ),
	//	  nID( _nID ), strName( _strName ), strLeaderName( _sdtrLeaderName ), nMemberCount( _nMemberCount )
	//{}

	// 연합길드정보 설정.
	void SetAllianceGuild( int _nAllianceID, std::string & _strAllianceName, int _nAllianceMemberCount, int _nAllianceMasterGuildSID, std::string & _strAllianceLeaderName )					
	{
		nAllianceID = _nAllianceID;  strAllianceName = _strAllianceName;  nAllianceMemberCount = _nAllianceMemberCount;  nAllianceMasterGuildSID = _nAllianceMasterGuildSID;
		strAllianceLeaderName = _strAllianceLeaderName;
	}	
};



typedef struct MemberInfo
{
	AR_HANDLE hPlayer;
	std::string strName;
	int nJobID;
	int nLevel;
	bool bLeader;
	int  nLogin;	///< 0:LogOff	|	1:LogIn	|	2:친구목록에서 차단당한 상태(내가 차단한게 아니고 MemberInfo 정보 당사자가 나를 차단한 경우)
	bool bNear;
	int nAuthority; // 권한등급.  추가 2010.04.13  bintitle  
					// 0   : 길드 관련 권한 없음(길드 비 소속 유저)
					// 1~6 : 길드에서 지정한 6개의 권한 세트
					// 7   : 길드  마스터

	std::string strMemo; // 길드 메모.
	AR_HANDLE hCreature[2];

	int nPoint;
	int nTotalPoint;

	MemberInfo()
	{
		hPlayer = NULL;
		strName.clear();
		nJobID = 0;
		nLevel = 0;
		//nPoint = 0;
		bLeader = false;
		nLogin	= true;
		bNear	= true;
		nAuthority = 0; 
		hCreature[0] = hCreature[1] = 0;
		nPoint = 0;
		nTotalPoint = 0;
	};
} MEMBER_INFO;
typedef struct MemberStat
{
	int nHP;
	int nMP;
	int nX;
	int nY;
	int nCreature[2];

	MemberStat()
	{
		nHP = 0;
		nMP = 0;
		nX = 0;
		nY = 0;

		::memset( nCreature, -1, sizeof(nCreature) );
	};
} MEMBER_STAT;

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
class SPlayerSlot
{
public:
	SPlayerSlot() {};
	virtual ~SPlayerSlot() {};

	void SetMainCreatureHandle( AR_HANDLE hMain )  { m_MemberInfo.hCreature[0] = hMain; }
	void SetSubCreatureHandle( AR_HANDLE hSub )	   { m_MemberInfo.hCreature[1] = hSub; }
	const AR_HANDLE GetMainCreatureHandle()        { return m_MemberInfo.hCreature[0]; }
	const AR_HANDLE GetSubCreatureHandle()	       { return m_MemberInfo.hCreature[1]; }

	// info
	const AR_HANDLE GetHandle() const	{ return m_MemberInfo.hPlayer; };
	const char* GetName() const { return m_MemberInfo.strName.c_str(); };
	const int GetJobID() const	{ return m_MemberInfo.nJobID; };
	const int GetLevel() const	{ return m_MemberInfo.nLevel; };
	const int GetPoint() const	{ return m_MemberInfo.nPoint; };
	const int GetTotalPoint() const	{ return m_MemberInfo.nTotalPoint; };
	const bool IsLeader() const { return m_MemberInfo.bLeader; };
	const int GetLogin() const	{ return m_MemberInfo.nLogin; }; // bintitle. 
	const bool IsLogin() const	{ return m_MemberInfo.nLogin==1; };
	const bool IsDenial() const	{ return m_MemberInfo.nLogin==2; };
	const bool IsNear() const	{ return m_MemberInfo.bNear; };

	// stat
	const int GetHP() const	{ return m_MemberStat.nHP; };
	const int GetMP() const	{ return m_MemberStat.nMP; };
	const int GetXPos() const	{ return m_MemberStat.nX; };
	const int GetYPos() const	{ return m_MemberStat.nY; };
	const int GetCreature( int nIndex ) const	
	{ 
		if( nIndex >= 2 || nIndex < 0 ) 
		{
			assert( false );
			return -1;
		}
		return m_MemberStat.nCreature[nIndex];
	};
	const int GetAuthority() { return m_MemberInfo.nAuthority; } // 권한등급. 추가 2010.04.13  bintitle
	const std::string & GetGuildMemo(){ return m_MemberInfo.strMemo; }     // 길드메모.

    void SetHandle( AR_HANDLE hPlayer )	{ m_MemberInfo.hPlayer = hPlayer; };
	void SetName( const char* szName )	{ m_MemberInfo.strName = szName; };
	void SetJobID( int nJobID ) 		{ m_MemberInfo.nJobID = nJobID; };
	void SetLevel( int nLevel )			{ m_MemberInfo.nLevel = nLevel; };
	void SetLeader( bool bLeader )		{ m_MemberInfo.bLeader = bLeader; };
	void SetLogin( int nLogin )			{ m_MemberInfo.nLogin = nLogin; };
	void SetNear( bool bNear )			{ m_MemberInfo.bNear = bNear; };
	void SetAuthority( int nAuthority ) { m_MemberInfo.nAuthority = nAuthority; } // 권한등급. 추가 2010.04.13  bintitle
	void SetGuildMemo( std::string & strMemo ){ m_MemberInfo.strMemo = strMemo; } // 길드메모.
	void SetPoint( int nPoint )			{ m_MemberInfo.nPoint = nPoint; }
	void SetTotalPoint( int nTotalPoint ){ m_MemberInfo.nTotalPoint = nTotalPoint; }

	void SetHP( int nHP ) { m_MemberStat.nHP = nHP; };
	void SetMP( int nMP ) { m_MemberStat.nMP = nMP; };
	void SetXPos( int nPosX ) { m_MemberStat.nX = nPosX; };
	void SetYPos( int nPosY ) { m_MemberStat.nY = nPosY; };
	void SetCreature( int nSlot, int nIndex )	{ m_MemberStat.nCreature[nIndex] = nSlot; };
	
private:
	MEMBER_INFO	m_MemberInfo;
	MEMBER_STAT	m_MemberStat;
};

class SRaidInfo
{
public:
	SRaidInfo(){};
	virtual ~SRaidInfo(){};

	void SetPartyID( int PartyID )					{ nParty_id       = PartyID;      }
	void SetLeaderName( const char* LeaderName )	{ strLeader_name  = LeaderName;   }
	void SetLeaderLv( int nLv )	{ nleader_lv  = nLv;   }
	void SetLeaderJob_id( int LeaderJobId )			{ nLeader_job_id  = LeaderJobId;  }
	void SetMemberCount( int MemberCount )			{ nMember_count   = MemberCount;  }
	void SetGguildParty( bool IsGuildParty )		{ bIs_guild_party = IsGuildParty; }

	const int  GetPartyID()		{ return nParty_id; }
	const char*GetLeaderName()	{ return strLeader_name.c_str(); }
	const int  GetLeaderLv()	{ return nleader_lv;   }
	const int  GetLeaderJob_id(){ return nLeader_job_id; }
	const int  GetMemberCount() { return nMember_count; }
	const bool IsGuildParty() { return bIs_guild_party; }

private:
	int			nParty_id;			///< party_id
	std::string strLeader_name;		///< leader_name
	int			nleader_lv;			///< leader_lv
	int			nLeader_job_id;		///< leader_job_id
	int			nMember_count;		///< member_count
	bool		bIs_guild_party;	///< is_guild_party

public:
	void SetPartyName(const char* PartyName) {	strParty_name = PartyName;	}
	const char*GetPartyName()	{	return strParty_name.c_str();	}
	void SetParytNum(int Num)		{ nPartyNum = Num; }
	const int GetPartyNum()			{ return nPartyNum; }

private:
	std::string strParty_name;		// party_name - 2011. 10. 18 - marine
	int			nPartyNum;			// 파티 번호
};

class PartyNumCompare : public std::binary_function<SRaidInfo*,SRaidInfo*,bool>
{
public:
	PartyNumCompare(){}
	bool operator()(SRaidInfo *r1,SRaidInfo *r2) const
	{
		return r1->GetPartyNum() < r2->GetPartyNum();
	}
};
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
class SMessengerMgr : public SGameUIMgr
{
public:

	//// 길드 권한등급 비트플래그(권한세트).
	//enum E_AUTHORITY{ 
	//	AUTHORITY_CLASS_1=0, AUTHORITY_CLASS_2, AUTHORITY_CLASS_3, AUTHORITY_CLASS_4, AUTHORITY_CLASS_5, AUTHORITY_CLASS_6, AUTHORITY_MAX
	//};

public:
	SMessengerMgr()
	: SGameUIMgr()  // 2011.03.29 - servantes
	{

		//// 길드 권한등급 비트플래그(권한세트).
		//for( int i=0; i<E_AUTHORITY::AUTHORITY_MAX; i++ )
		//	m_arrAuthorityClass[ i ] = 0; 
		m_bSelf = false;
		m_bShow = false;   //2011.10.31 : servantes
	}
	virtual ~SMessengerMgr();

	virtual void Clear();
	virtual void Free();

    virtual void SetPlayerInfo( AR_HANDLE hPlayer, const char* szName )
	{
		m_hLocalPlayer = hPlayer;
		m_strLocalPlayerName = szName;
	};

	//virtual int AddMessage( const char* szMsg );
	virtual int AddMessage( const char* szMsg, bool & bSelf ); // 2010.11.29. bintitle. 메세지가 자신에게만 해당되는지 여부 반환.
	virtual void InfoMember( STR_LIST& vecText ) {};
	//virtual void AddMember( STR_LIST& vecText ) {};
	virtual void AddMember( STR_LIST& vecText, bool & bSelf ) {}; // 2010.11.29. bintitle. 메세지가 자신에게만 해당되는지 여부 반환.
			
	// 2011.11.23 - servantes : 리턴형 변경
	virtual bool CreateCommunity( const char* szCommunityName );
	virtual bool CreateCommunity( const char* szCommunityName, char const* leaderName );
	virtual bool RefreshMember( STR_LIST& vecText );
	virtual bool JoinMember( const char* szPlayerName, const char* szPartyName );
	virtual bool LeaveMember( const char* szPlayerName );
	virtual bool LoginMember( const char* szPlayerName );
	virtual bool LogoutMember( const char* szPlayerName );
	virtual bool ChangeLeader( const char* szPlayerName );
	virtual bool AddMember( const char* szPlayerName );
	virtual bool AddMember( SPlayerSlot* pSlot );   // 2011.12.05 - servantes
	virtual bool DeleteMember( const char* szPlayerName );

	virtual SPlayerSlot* FindMember( AR_HANDLE hPlayer );
	virtual SPlayerSlot* FindMember( const char* szPlayerName );

	int FindMemberIndex( AR_HANDLE hPlayer );    // 2011.11.04 - servantes : 이름으로 해당 인덱스를 찾는다
	SPlayerSlot* FindMemberByID( int id );       // 2011.12.19 - servantes : 이름으로 해당 인덱스를 찾는다
	SPlayerSlot* FindMemberHandle( AR_HANDLE hPlayer );

	virtual SPlayerSlot* FindMemberByCreature(AR_HANDLE hCreature);	/// 2012.01.12 - prodongi
	virtual SPlayerSlot* GetLeaderInfo();

	void SetSelectMember( const char* szName ) { m_strSelectMember = szName; };
	
	void SetSelectMemberHandle( AR_HANDLE hTarget ) { m_hSelectMemberHandle = hTarget; }	///< 선택 된 파티원 핸들 설정.
	AR_HANDLE GetSelectMemberHandle() { return m_hSelectMemberHandle; }						///< 선택 된 파티원 핸들 불러오기.

	virtual const int GetMaxLevel() const { return m_nMaxLevel; };
	virtual const int GetMinLevel() const { return m_nMinLevel; };
	virtual const AR_HANDLE GetMemberHandle( const char* szName );
	virtual const char* GetMessage()  { return m_strMsg.c_str(); };
	virtual const char* GetSelectMember() { return m_strSelectMember.c_str(); };
		
	virtual const bool IsExist() const	{ return m_bIsExist; };
	virtual const bool IsExistMember( AR_HANDLE hPlayer ) const;
	// 2010.07.27 - prodongi
	virtual const bool IsExistLoginMember(AR_HANDLE hPlayer) const;
	virtual const int  GetMemberIndex( AR_HANDLE hPlayer ) const;
	virtual const int  GetLeaderIndex() const;
	virtual const bool IsExistMember( const char* szPlayerName ) const;
	virtual const bool IsLeader() const { return ( ::_stricmp(m_strLocalPlayerName.c_str(), m_strLeaderName.c_str()) == 0 ); };
	virtual const bool IsFar( AR_HANDLE hPlayer ) const;
	virtual const bool IsLocalPlayer( AR_HANDLE hPlayer )	{	return (hPlayer==m_hLocalPlayer) ? true : false;	};
	
	virtual std::vector<SPlayerSlot*>& GetMemberList() { return m_vecMemberList; };
	virtual const int GetMemberCount() const	{ return static_cast<int>(m_vecMemberList.size()); };
	virtual const int GetLoginMemberCount();
	
	//// 권한비트셋 등급 변경.
	//void ChangeAuthorityClassBitSet( E_AUTHORITY eClass, int bitSet ){
	//	m_arrAuthorityClass[ eClass ] = bitSet;
	//}

	//// 권한비트셋 등급해당명 변경.
	//void ChangeAuthorityClassNameBitSet( E_AUTHORITY eClass, std::string & strClassName ){
	//	m_arrAuthorityClassName[ eClass ] = strClassName;
	//}

	void SetPartyName(const char* pPartyName)   { m_strCommunityName = pPartyName; }
	void SetLeaderName(const char* pLeaderName) { m_strLeaderName = pLeaderName; }
	void SetLocalPlayerName(const char* pLocalPlayerName) { m_strLocalPlayerName = pLocalPlayerName; }
	void SetGuildLeaderName(const char* pGuildLeaderName) { m_strGulidLeaderName = pGuildLeaderName; }
	void SetMaxLevel(int nMaxLV) { m_nMaxLevel = nMaxLV; }
	void SetMinLevel(int nMinLV) { m_nMinLevel = nMinLV; }
	void SetPartyType(int nPartyType)           { m_nPartyType = nPartyType; }
	int  GetPartyType()                         { return m_nPartyType; }
	const char* GetLocalPlayerName()            { return m_strLocalPlayerName.c_str(); }
	void SetShow(bool b)                        { m_bShow = b; }
	bool IsShow()                               { return m_bShow; }
	void SetExist(bool b)                       { m_bIsExist = b; }

protected:
	std::vector<SPlayerSlot*>	m_vecMemberList;

	AR_HANDLE	m_hLocalPlayer;
	std::string m_strLocalPlayerName;

	bool m_bParsing;
	bool m_bIsExist;
	int	m_nMaxLevel;
	int	m_nMinLevel;

	int m_nCommunityID;
	int m_nCommunityPassword;

	std::string m_strMsg;
	std::string m_strSelectMember;	
	std::string m_strLeaderName;

	std::string m_strCommunityName;

	std::string m_strGuildName;
	std::string m_strBattleCommanderName;	///< sonador 3.5.1	던전 시즈 레벨 제한
	std::string m_strGulidLeaderName;

	AR_HANDLE	m_hSelectMemberHandle;

	int m_nPartyType;  // 2011.10.20 : servantes : 파티타입
	bool m_bShow;

	void SetPartyMemberHpBar(std::string &str);				// 2012. 6. 19 - marine 파티원,파티원 크리쳐 hp게이지 설정

public : 
		bool m_bSelf; // bintitle. 2010.11.29.

		bool GetParsingFlag() { return m_bParsing; }
	////---------------------
	//// 추가. bintitle

	//int m_nMemberCount;			// 길드 맴버 수.	
	//std::string m_strNotice;	// 길드공지
	//int m_bRecruitment;			// 길드원 모집 여부.
	//int m_nDungeonID;			// 소유던전ID

	//int m_arrAuthorityClass[ E_AUTHORITY::AUTHORITY_MAX ]; // 길드 권한등급 비트플래그(권한세트).  등급단위수.
	//std::string m_arrAuthorityClassName[ E_AUTHORITY::AUTHORITY_MAX ]; // 길드 권한등급 비트플래그(권한세트).  등급명.

	bool m_bCreate;
};

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
class SPartyMgr : public SMessengerMgr
{
public:
	SPartyMgr();

	virtual void Clear();

	//virtual int AddMessage( const char* szMsg );
	virtual int AddMessage( const char* szMsg, bool & bSelf ); // 2010.11.29. bintitle. 메세지가 자신에게만 해당되는지 여부 반환.
	virtual void InfoMember( STR_LIST& vecText, int nStartTap=-1 );
	virtual bool DeleteMember( const char* szPlayerName );
	virtual bool AddMember( const char* szName );
	virtual bool AddMember( SPlayerSlot* pSlot );
	virtual bool JoinMember( const char* szPlayerName,  const char* szCommunityName );

	void ChangePartyInfo( STR_LIST& vecPartyText );		// list	
	void ChangePartyDivision( const char* szMode );
	const int GetDivision() const { return m_nDivisionMode; };

	const char* GetPartyName() { return m_strCommunityName.c_str(); };
	const char* GetPartyLeaderName();
	const bool IsPartyLeader();

	const int GetPartyID() const	{ return m_nCommunityID; };
	const int GetPartyPass() const	{ return m_nCommunityPassword; };

	void		ResetInfo();

	bool IsMyParty();	// 2011.12.07 - servantes : 내가 속한 파티인지 검사
//	void InfoMember( STR_LIST& vecText, int nStartTap );
	void SetPartyID(int ID)                    { m_nCommunityID = ID; }
	void SetnDivisionMode(int nDivisionMode)   { m_nDivisionMode = nDivisionMode; }

public:	// 2011.10.19 : servantes 접근할 필요가 생겨서 바꿈
	// 2011.11.23 - servantes : 리턴형 변경
	bool UpdatePartyPosition( STR_LIST& data );	///< sonador 3.12.1	파티원 좌표 갱신 기능 추가

protected:
	void checkValidArenaJoinSituation();

private:
	int m_nDivisionMode;
};


class CPartyListMgr : public SPartyMgr //SMessengerMgr
{
public:
	CPartyListMgr();
	virtual ~CPartyListMgr();

	// int nPartyID ( -1 ) : my party id
	SPartyMgr*       GetParty(std::string* pstrPartyName = NULL);     // 파티매니저를 찾는다 ( -1 은 내 파티 )

	bool             IsLeader(std::string* pstrPartyName = NULL);
	bool             IsPartyLeader(std::string* pstrPartyName = NULL);
	bool             IsLocalPlayer( AR_HANDLE hPlayer, std::string* pstrPartyName = NULL );
	bool             IsExist(std::string* pstrPartyName = NULL);

	void             SetPlayerInfo( AR_HANDLE hPlayer, const char* szName, std::string* pstrPartyName = NULL );
	void             SetSelectMember( const char* szName, std::string* pstrPartyName = NULL );
	void             SetSelectMemberHandle( AR_HANDLE hTarget, std::string* pstrPartyName = NULL );	///< 선택 된 파티원 핸들 설정.

	
	int              GetPartyType(std::string* pstrPartyName = NULL);
	const char*      GetMessage(std::string* pstrPartyName = NULL);
	int              GetPartyPass(std::string* pstrPartyName = NULL);
	const char*      GetPartyLeaderName(std::string* pstrPartyName = NULL);
	int              GetDivision(std::string* pstrPartyName = NULL);
	const char*      GetSelectMember(std::string* pstrPartyName = NULL);
	int              GetPartyID(std::string* pstrPartyName = NULL);
	int              GetMemberCount(std::string* pstrPartyName = NULL);
	const char*      GetPartyName(std::string* pstrPartyName = NULL);
	AR_HANDLE        GetSelectMemberHandle(std::string* pstrPartyName = NULL);						///< 선택 된 파티원 핸들 불러오기.
	std::vector<SPlayerSlot*>& GetMemberList(std::string* pstrPartyName = NULL);

	int              AddMessage( const char* szMsg, bool & bSelf ); // 2010.11.29. bintitle. 메세지가 자신에게만 해당되는지 여부 반환.
	void             InfoMember( STR_LIST& vecText );
	void             InfoRaidMember( STR_LIST& vecText );
	
	void             ChangePartyInfo( STR_LIST& vecPartyText, std::string* pstrPartyName = NULL );		// list	
	void             ChangePartyDivision( const char* szMode, std::string* pstrPartyName = NULL );

	bool             CreateCommunity( const char* szCommunityName, std::string* pstrPartyName = NULL );
	bool             RefreshMember( STR_LIST& vecText, std::string* pstrPartyName = NULL );
	bool             JoinMember( const char* szPlayerName,  std::string* pstrPartyName);
	/// 2012.07.23 leaveType:0 일반적인 탈퇴, 1 아레나 참여로 인한 탈퇴
	bool             LeaveMember( const char* szPlayerName, std::string* pstrPartyName = NULL, char const* leaveType = NULL );
	bool             LoginMember( const char* szPlayerName, std::string* pstrPartyName = NULL );
	bool             LogoutMember( const char* szPlayerName, std::string* pstrPartyName = NULL );
	bool             ChangeLeader( const char* szPlayerName, std::string* pstrPartyName = NULL );
	bool             AddMember( const char* szName, std::string* pstrPartyName = NULL );
	bool             AddMember( SPlayerSlot* pSlot, std::string* pstrPartyName = NULL );
	bool             DeleteMember( const char* szName, std::string* pstrPartyName = NULL );
	SPlayerSlot*     FindMember( AR_HANDLE hPlayer, std::string* pstrPartyName = NULL );
	SPlayerSlot*     FindMember( const char* szName, std::string* pstrPartyName = NULL );
	SPlayerSlot*     GetLeaderInfo(std::string* pstrPartyName = NULL);
	AR_HANDLE        GetMemberHandle( const char* szName, std::string* pstrPartyName = NULL );
	AR_HANDLE        GetMemberHandleSearchAllParty( const char* szName );    // 2011.11.11 - servantes : 파티 전체에서 캐릭터 이름으로 핸들을 찾는다
	int              GetLoginMemberCount(std::string* pstrPartyName = NULL);
	bool             IsFar( AR_HANDLE hPlayer, std::string* pstrPartyName = NULL );
	bool             IsExistMember( AR_HANDLE hPlayer, std::string* pstrPartyName = NULL );
	bool             IsExistLoginMember(AR_HANDLE hPlayer, std::string* pstrPartyName = NULL);
	bool             IsExistMember( const char* szName, std::string* pstrPartyName = NULL );
	int              GetMemberIndex( AR_HANDLE hPlayer, std::string* pstrPartyName = NULL );
	int              GetLeaderIndex(std::string* pstrPartyName = NULL);
	
	void             Clear();
	void             Add(SPartyMgr* pSPartyMgr);
	void             Delete(std::string* pstrPartyName);
	SPartyMgr*       Find(std::string* pstrPartyName);   // -1 : 내 파티
	SPartyMgr*		Find(int partyId);			/// 2011.12.22 파티 id로 파티를 찾는다 - prodongi
	SPartyMgr*       FindIncludeSlef(std::string* pstrPartyName);   // -1 : 내 파티
	SPartyMgr*       FindPartyByPlayerName(std::string* pstrPlayerName);  // 해당 이름의 캐릭터가 소속된 파티를 찾는다
	SPartyMgr*       FindPartyByPartyName(std::string* pstrPartyName);
	SPartyMgr*       FindPartyByLeaderName(std::string* pstrLeaderName);            // 해당 이름의 리더가가 소속된 파티를 찾는다
	int              FindPartyID(std::string* pPartyName);                          // 해당 이름의 파티가의 아이디를 찾는다
//	int              GetMyPartyID()   { return m_nMyPartyID; }                 // 내파티 아이디
//	int              GetMyPartyType() { return m_nMyPartyType; }               // 내파티 타입
	int              GetPartyCount() { return (int)m_mapPartyInfoList.size(); }
	char const* getOldPartyName() const	{	return m_oldCommunityName.c_str();	}
	void checkValidArenaJoinSituationByLeaveAtArena();
	bool isArenaParty() const		{	return m_isArenaParty;	}

	SPartyMgr*       FindPartyByPlayerHandle(AR_HANDLE hPlayer);
	virtual SPlayerSlot* FindMemberByCreature(AR_HANDLE hCreature, std::string& partyName);

	SPartyMgr*       FindPartyByID(int nPartyID);
	void             SummonInfo( STR_LIST& vecText );
	void             MemberSummonInfo( STR_LIST& vecText );

private:	
	bool UpdatePartyPosition( STR_LIST& data, std::string* pstrPartyName = NULL );	///< sonador 3.12.1	파티원 좌표 갱신 기능 추가
	void createParty(std::string& partyName, std::string& partyLeaderName, int partyType);		/// 2012.01.04 파티 생성 공통으로 쓰기 위해 함수로 뺌 - prodongi

	bool             m_bRecvJoinOrLogin;                          // 조인 메세지를 받았다는 플래그
	std::map<std::string, SPartyMgr*> m_mapPartyInfoList;  // 파티리스트의 정보가 들어있는 맵
	int              m_nMyPartyID;
	std::string m_oldCommunityName;	/// 자신이 파티 탈퇴 했을 때, 파티 이름을 삭제 하기 때문에, 채팅 메세지로 파티 이름을 뿌려주기위해 저장됨
	bool m_isArenaParty;
};

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//
class SRaidMgr : public SGameUIMgr
{
public:
	SRaidMgr();
	virtual ~SRaidMgr();
	virtual void Clear();

	virtual int AddMessage( const char* szMsg );	

	virtual void InfoRaid( STR_LIST& vecText );
	void InfoArena(STR_LIST& vecText);	/// 2012.06.08 - prodongi

	std::vector< SRaidInfo* >& GetRaidInfoList() { return m_pRaidInfoList; }

	void DeleteParty( const char* lpPartyName );

	const char* GetPartyManagerName()	{	return strPartyManagerName.c_str();	}
	const char* GetPartyName()			{	return strPartyName.c_str();		}
	const int	GetPartyID()			{	return nRaidPartyID;				}
	const int	GetPartyPassWord()		{	return nRaidPartyPass;				}
	int getArenaType() const	{	return m_arenaType;	}

	const char* GetMercenaryPartyManagerName()	{	return strMercenaryPartyManagerName.c_str();	}
	const char* GetMercenaryPartyName()			{	return strMercenaryPartyName.c_str();			}
	const int	GetMercenaryPartyID()			{	return nMercenaryRaidPartyID;					}
	const int	GetMercenaryPartyPassWord()		{	return nMercenaryRaidPartyPass;					}
    const int GetMainPartyID()	{	return m_nMainPartyID;	}
	const int GetPartyCount()	{	return m_pRaidInfoList.size();	}
	const int	GetMaxGuildPartyNum()	{	return m_nMaxGuildPartyNum;	}
	const int	GetMaxMercenaryPartyNum()	{	return m_nMaxMercenaryPartyNum;	}
	
	void		ResetInfo();

	char const* getLeaderName(int index);	/// 2011.10.13 - prodongi
	SRaidInfo*  GetRaidInfo(int index);	    /// 2011.10.28 - servantes
	SRaidInfo*  GetTopRaidInfo();	        /// 2011.12.07 - servantes
	SRaidInfo*  GetRaidInfo(const char* pPartyName);	    /// 2011.12.05 - servantes

	const int getAimDungeonID() {return m_nAimDungeonID; };		// 2011. 10 .18 - marine
	const char* getAttackUnitLeaderName();						// 2011. 10. 18 - marine 공대장 이름
	const char* getAttackUnitName(){return m_strAttackUnitName.c_str();};	// 2011. 11. 2 - marine 공대 이름
	void setAttackUnitName(const char* pAttackUnitName) { m_strAttackUnitName = pAttackUnitName; };	// 2011.12.05 - marine 공대 이름
	const std::string getAttackUnitPartyName(int nPartyID);		// 2011. 11. 15 - marine 공대파티 이름..1공대,2공대 등의 박힌 이름..
	void setJoinPartyData(STR_LIST &raid_info );					// 2011. 12 .15 - marine 추가된 공대파티데이터 설정
	void setPartyCount( std::string &strPartyName, int nMemberCount );	// 2011. 12. 20 - marine
	// 2011.11.16 - servantes : 이름으로 레이드의 지정된 이름( 제1공대, 제2공대... 로 디비에 저장되어 있는 이름 ) 을 찾는다
	const std::string getAttackUnitPartyName(const char* pPartyName);
	bool isPartyLeaderPlayer(char const* playerName);	/// 2011.12.19 파티장 인지 아닌지 - prodongi
	void pushRaidInfo(SRaidInfo* pInfo);			// 2011. 12. 20 - marine 기존코드때문에 소팅이필요..
	int	getNumUseAttackUnit(std::string &);			// 2011. 12. 23 - marine 공대에서 사용되는 순서번호를 파티이름으로 얻는다.(공대UI상에서의 순번)
	int	getNumberAtPartyName(std::string partyName);		// 2012. 1. 10 - marine 파티이름으로 몇번파티인지 얻는 함수 ex) 공대장파티는 0번, 파티_00는 1번...파티_06은 8번을 리턴

protected:
	std::vector< SRaidInfo* > m_pRaidInfoList;

	int m_nMainPartyID		  ;
	int m_nMaxGuildPartyNum	  ;
	int m_nMaxMercenaryPartyNum;
	int m_nAimDungeonID;					// 2011. 10 .18 - marine 던전시즈 목표 던전 아이디
	std::string m_strAttackUnitName;			// 2011. 11. 2 - marine 공대 이름
	// 공대 이름은 별도로 있는게 아니라 (공대장이 속한 파티 이름)이(공대 이름)이다.
	// 1번 파티(팔미르공대) -> 공대장 파티이름이면서 공대 이름
	// 2번 파티(팔미르공대_00)
	// 3번 파티(팔미르공대_01)
	// ...
	// 이런 방식으로 클라랑 서버에서 파티이름을 사용하지만 UI상 보여지는 파티 이름은
	// 1번 파티(1 공대 파티)
	// 2번 파티(2 공대 파티)
	// ...
	// 위와 같은 식으로 실제 클라, 서버에서 사용되는 파티 이름과 UI상 보여지는 이름은 다르다.

	//Guild Invite
	std::string	strPartyManagerName;
	std::string	strPartyName;
	int			nRaidPartyID;
	int			nRaidPartyPass;
	/// 2012.06.08 - prodongi
	/// TYPE_BATTLE_ARENA_TEAM or TYPE_BATTLE_ARENA_EXERCISE_TEAM 중에 하나의 값이어야 한다
	int m_arenaType;

	//Mercenary Invite
	std::string	strMercenaryPartyManagerName;
	std::string	strMercenaryPartyName;
	int			nMercenaryRaidPartyID;
	int			nMercenaryRaidPartyPass;
};


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//

//enum GUILD_UPDATE
//{
//	GUILD_UPDATE_NONE = 0,
//	GUILD_UPDATE_INVITE,				// INVITE|파티장이름|[파튀,길드]이름|파티ID|파티PW|
//	GUILD_UPDATE_KICK,					// KICK|[파튀,길드]이름|캐릭이름	
//	GUILD_UPDATE_LOGIN,					// LOGIN|[파튀,길드]이름|캐릭이름
//	GUILD_UPDATE_CHANGE_NAME,			//CHANGE_NAME|old_name|new_name|
//	GUILD_UPDATE_CHANGE_GUILD_NAME,		//CHANGE_GUILD_NAME|guild_id|guild_name|
//	GUILD_UPDATE_CHANGE_LEVEL,			//CHANGE_NAME|캐릭터이름|레벨|
//	GUILD_UPDATE_CHANGE_JOB,			//CHANGE_NAME|캐릭터이름|직업|
//	GUILD_UPDATE_CREATE,				// CREATE|[파튀,길드]이름|파튀장
//	GUILD_UPDATE_JOIN,					// JOIN|[파튀,길드]이름|	// 새 멤버(=자기자신)에게
//	GUILD_UPDATE_NEW,					// NEW|캐릭이름|	// 기존 멤버에게만
//	GUILD_UPDATE_LEAVE,					// LEAVE|캐릭이름
//	GUILD_UPDATE_LOGOUT,				// LOGOUT|캐릭이름
//	GUILD_UPDATE_PROMOTE,				// PROMOTE|캐릭이름	// 파티장 변경
//	GUILD_UPDATE_GINFO,					// GINFO , 길드SID, 길드명, 길마이름, 멤버수, 길드공지, 멤버모집 중 여부, 소유던전ID
//	GUILD_UPDATE_MINFO,					// MINFO|AR_HANDLE|이름|레벨|직업CODE|권한등급|HP%|MP%|X|Y|온/오프라인|
//	GUILD_UPDATE_DESTROY,				// DESTROY|[파티,길드]이름
//	GUILD_UPDATE_GMEMBER,				// GMEMBER|AR_HANDLE|이름|레벨|직업CODE|권한등급|HP%|MP%|X|Y|온/오프라인|
//	GUILD_UPDATE_LIST,					// LIST|캐릭이름|분배방|최고렙|최저
//	GUILD_UPDATE_MEMO,					// MEMO|유저명|메모 내용
//	GUILD_UPDATE_AINFO,					// 연합길드 정보.
//	GUILD_UPDATE_CHANGE_PERMISSION,		// 권한등급변경.  캐릭터명|권한등급
//	GUILD_UPDATE_CHANGE_PERMISSION_SET, // 권한등급비트플래그(권한세트) 변경.  권한등급|권한_비트셋
//	GUILD_UPDATE_GPERMISSION,			// 권한등급   권한이름1|권한셋1|권한이름2|권한셋2|권한이름3|권한셋3|권한이름4|권한셋4|권한이름5|권한셋5|권한이름6|권한셋6
//	GUILD_UPDATE_NOTICE,				// 길드공지  NOTICE|공지내용
//	GUILD_UPDATE_CHANGE_PERMISSION_NAME,// 권한이름.   CHANGE_PERMISSION_NAME|권한번호|변경 후 권한이름
//	GUILD_UPDATE_URL,					// 길드 URL.  URL|%s
//	GUILD_UPDATE_GRAIDSIEGETIP,			// 길드 던전 레이드/시즈.  GRAIDSIEGETIP | 정보 타입 | 타임 레코드 | 길드 이름 | 길마 이름 | 길드원 수 | 던전 ID
//	GUILD_UPDATE_ERROR_PERMISSION,		// 길드원 추방시 추방대상이 등급이 높은경우.
//	GUILD_UPDATE_ERROR_NOT_EXIST,		// 길드원 초대시 없는 캐릭터 인경우.
//	GUILD_UPDATE_GUPGRADE				//
//	GUILD_UPDATE_GDONATION				//
//	GUILD_UPDATE_GBUFF					//
//
//	GUILD_UPDATE_MAX
//};

enum GUILD_UPDATE  // 길드UI open 전까지 Refresh 조건을 보관하기위해 bitset 으로 변경.
{
	GUILD_UPDATE_NONE					= 1<<0,
	GUILD_UPDATE_INVITE					= 1<<1,	// INVITE|파티장이름|[파튀,길드]이름|파티ID|파티PW|
	GUILD_UPDATE_KICK					= 1<<2,	// KICK|[파튀,길드]이름|캐릭이름	
	GUILD_UPDATE_LOGIN					= 1<<3,	// LOGIN|[파튀,길드]이름|캐릭이름
	GUILD_UPDATE_CHANGE_NAME			= 1<<4,	//CHANGE_NAME|old_name|new_name|
	GUILD_UPDATE_CHANGE_GUILD_NAME		= 1<<5,	//CHANGE_GUILD_NAME|guild_id|guild_name|
	GUILD_UPDATE_CHANGE_LEVEL			= 1<<6,	//CHANGE_NAME|캐릭터이름|레벨|
	GUILD_UPDATE_CHANGE_JOB				= 1<<7,	//CHANGE_NAME|캐릭터이름|직업|
	GUILD_UPDATE_CREATE					= 1<<8,	// CREATE|[파튀,길드]이름|파튀장
	GUILD_UPDATE_JOIN					= 1<<9,	// JOIN|[파튀,길드]이름|	// 새 멤버(=자기자신)에게
	GUILD_UPDATE_NEW					= 1<<10,// NEW|캐릭이름|	// 기존 멤버에게만
	GUILD_UPDATE_LEAVE					= 1<<11,// LEAVE|캐릭이름
	GUILD_UPDATE_LOGOUT					= 1<<12,// LOGOUT|캐릭이름
	GUILD_UPDATE_PROMOTE				= 1<<13,// PROMOTE|캐릭이름	// 파티장 변경
	GUILD_UPDATE_GINFO					= 1<<14,// GINFO , 길드SID, 길드명, 길마이름, 멤버수, 길드공지, 멤버모집 중 여부, 소유던전ID
	GUILD_UPDATE_MINFO					= 1<<15,// MINFO|AR_HANDLE|이름|레벨|직업CODE|권한등급|HP%|MP%|X|Y|온/오프라인|
	GUILD_UPDATE_DESTROY				= 1<<16,// DESTROY|[파티,길드]이름
	GUILD_UPDATE_GMEMBER				= 1<<17,// GMEMBER|AR_HANDLE|이름|레벨|직업CODE|권한등급|HP%|MP%|X|Y|온/오프라인|
	GUILD_UPDATE_LIST					= 1<<18,// LIST|캐릭이름|분배방|최고렙|최저
	GUILD_UPDATE_MEMO					= 1<<19,// MEMO|유저명|메모 내용
	GUILD_UPDATE_AINFO					= 1<<20,// 연합길드 정보.
	GUILD_UPDATE_CHANGE_PERMISSION		= 1<<21,// 권한등급변경.  캐릭터명|권한등급
	GUILD_UPDATE_CHANGE_PERMISSION_SET	= 1<<22,// 권한등급비트플래그(권한세트) 변경.  권한등급|권한_비트셋
	GUILD_UPDATE_GPERMISSION			= 1<<23,// 권한등급   권한이름1|권한셋1|권한이름2|권한셋2|권한이름3|권한셋3|권한이름4|권한셋4|권한이름5|권한셋5|권한이름6|권한셋6
	GUILD_UPDATE_NOTICE					= 1<<24,// 길드공지  NOTICE|공지내용
	GUILD_UPDATE_CHANGE_PERMISSION_NAME = 1<<25,// 권한이름.   CHANGE_PERMISSION_NAME|권한번호|변경 후 권한이름
	GUILD_UPDATE_URL					= 1<<26,// 길드 URL.  URL|%s
	GUILD_UPDATE_GRAIDSIEGETIP			= 1<<27,// 길드 던전 레이드/시즈.  GRAIDSIEGETIP | 정보 타입 | 타임 레코드 | 길드 이름 | 길마 이름 | 길드원 수 | 던전 ID
	GUILD_UPDATE_ERROR_PERMISSION		= 1<<28,// 길드원 추방시 추방대상이 등급이 높은경우.
	GUILD_UPDATE_ERROR_NOT_EXIST		= 1<<29,// 길드원 초대시 없는 캐릭터 인경우.
	GUILD_UPDATE_DONATION				= 1<<30,

	GUILD_UPDATE_MAX = (1<<31),
};
//bool CheckGuildUpdateFlag( DWORD flags, DWORD oneFlag )
//{
//	return ( flags & oneFlag ) == oneFlag;
//}

// 공격대UI 정보.
struct SRaidSiege
{
	int nType; // 정보타입. 4종류( 0레이드 신청전, 1 레이드 신청후, 2 시즈방어길드, 3 시즈도전길드 ). 
	int nTime_hour; // 타임어택 시.
	int nTime_min;  // 분.
	int nTime_sec;  // 초.
	std::string strGuildName;
	std::string strGuildMaster;
	int nGuildCount; 
	int nGuildDungeon;

	SRaidSiege() :	nType(0), nTime_hour(0), nTime_min(0), nTime_sec(0), nGuildCount(0), nGuildDungeon(0)
	{}

	void Reset()
	{
		nType = 0; 
		nTime_hour = 0; nTime_min = 0;  nTime_sec = 0;  
		strGuildName = "";  strGuildMaster = "";
		nGuildCount = 0;  nGuildDungeon = 0;
	}

	void SetInfo( int _nType, int _nTime, std::string & _strGuildName, std::string & _strGuildMaster, int _nGuildCount, int _nGuildDungeon );
};

class SGuildMgr : public SMessengerMgr
{
public:
	// 길드 권한등급 비트플래그(권한세트).
	enum E_AUTHORITY{ 
		AUTHORITY_CLASS_1=0, AUTHORITY_CLASS_2, AUTHORITY_CLASS_3, AUTHORITY_CLASS_4, AUTHORITY_CLASS_5, AUTHORITY_CLASS_6, A_GUILDMASTER, AUTHORITY_MAX
	};


public:
	SGuildMgr();

	virtual void Clear();

	//virtual int AddMessage( const char* szMsg, int& nNewGuilID );
	virtual int AddMessage( const char* szMsg, int& nNewGuilID, bool & bSelf ); // 2010.11.29. bintitle. 해당메세지가 자신에게만 적용되는 지 여부.
	virtual void InfoMember( STR_LIST& vecText );
	//virtual void AddMember( STR_LIST& vecText );
	virtual void AddMember( STR_LIST& vecText, bool & bSelf ); // 2010.11.29. bintitle. 해당메세지가 자신에게만 적용되는 지 여부. 

	// 2011.11.23 - servantes : 리턴형 변경
	virtual bool RefreshMember( STR_LIST& vecText );
	
	void SetNotice( STR_LIST & vecText );					// 길드공지.
	void SetMemo( STR_LIST & vecText );						// 길드원 메모.
	void SetAllianceGuild( STR_LIST & vecText );			// 연합길드정보 설정.
	void ChangeAuthorityClass( STR_LIST & vecText );		// 권한등급변경.
	void ChangeAuthorityClassBitSet( STR_LIST & vecText );  // 권한등급비트플래그(권한세트) 변경.
	void SetAuthorityClass( STR_LIST & vecText );			// 권한등급 설정.
	void SetAuthorityClassName( STR_LIST & vecText );		// 권한등급명 설정.
	void SetURL( std::string & strURL );					// 길드 URL.
		
	void SetGradePoint( STR_LIST & vecText );
	void SetGuildMemberPoint( STR_LIST & vecText );
		
	// 권한비트셋 등급 변경.
	void ChangeAuthorityClassBitSet( E_AUTHORITY eClass, int bitSet ){
		m_arrAuthorityClass[ eClass ] = bitSet;
	}

	// 권한비트셋 등급해당명 변경.
	void ChangeAuthorityClassNameBitSet( int eClass, std::string & strClassName ){
		m_arrAuthorityClassName[ eClass ] = strClassName;
	}

	void ChangeGuildInfo( STR_LIST& vecPartyText );		// list

	void ChangeAllianceMemberCount( int nGID, int memberCount ); // 연합소속 길드원 멤버수 변경.
	void ChangeAllianceMaster( int nGID, const std::string & strName ); // 연합소속 길드장 변경.
	
	// 길드 던전 레이드/시즈 관련 정보설정.
	void SetRaidInfo( STR_LIST& vecRaid ); 

	///////

	/// 2011.05.11 함수명과 리턴값이 반대로 되어 있다, 왜?? - prodongi
	bool GetIsAlliance(){										// 연합길드 정보.
		return m_arrAllianceGuild.empty(); 
	}

	const std::vector< SAllianceGuild * > & GetAllianceGuild(){ // 연합길드 정보.
		return m_arrAllianceGuild; 
	}

	SAllianceGuild * GetAllianceGuildByIndex( int index ){		// 연합길드 정보.
		if( index >= 0 && index < (int)m_arrAllianceGuild.size() )
			return m_arrAllianceGuild[ index ]; 
		return NULL;	/// 2011.01.19 추가 - prodongi
	}

	SAllianceGuild * GetAllianceGuildByGID( int nGID );			// 연합에 속한 길드 반환.


	int GetAllianceSize(){										// 연합길드 수.
		return m_arrAllianceGuild.size();
	}

	const char * GetAllianceGuildMaster( int nGID );			// 연합길드장.
	const char * SGuildMgr::GetAllianceMasterToGuild();			// 연합길드장 소속길드 반환.


	// 길드 권한등급 비트플래그(권한세트).  등급명.
	const char * GetAuthorityClassName( int nClass ){
		if( nClass >= 0 && nClass < AUTHORITY_MAX )
			return m_arrAuthorityClassName[ nClass ].c_str(); 
		return NULL;
	}

	// 권한에 해당하는 권한비트셋 반환.
	int GetAuthorityClassBitSet( int nClass ){
		return m_arrAuthorityClass[ nClass ];
	}	
	int GetGuildDungeonID(){ return m_nDungeonID; }	// 소유던전ID

	const char * GetGuildNotice() { return m_strNotice.c_str(); } // 길드공지.
	const char* GetGuildName() { return m_strGuildName.c_str(); };
	const char* GetLocalPlayerName() { return m_strLocalPlayerName.c_str(); };
	const char* GetGuildLeaderName() { return m_strGulidLeaderName.c_str(); };	
	/// sonador 3.5.1	던전 시즈 레벨 제한
	const char* GetBattleCommanderName() { return m_strBattleCommanderName.c_str(); }
	bool IsLocalPlayerMaster()	{	return m_strLocalPlayerName == m_strGulidLeaderName;	}
	/// sonador 3.5.1	던전 시즈 레벨 제한
	bool IsLocalPlayerBattleCommander() { return m_strLocalPlayerName == m_strBattleCommanderName; }

	const char* GetCommunityName() { return m_strCommunityName.c_str(); };
	const char* GetCommunityLeaderName() { return m_strLeaderName.c_str(); };

	const int GetGuildID() const	{ return m_nCommunityID; };
	const int GetGuildPass() const	{ return m_nCommunityPassword; };

	const int GetGuildGrade() const { return m_nGrade; };
	const int GetGuildPoint() const { return m_nPoint; };
	const int GetGuildObjectif() const { return m_arrRank[ m_nGrade ]; }

	// 2011.11.23 - servantes : 리턴형 변경
	virtual bool ChangeLeader( const char* szPlayerName );

	virtual const int GetLoginMemberCount(); // 차단맴버포함 모든 로그인 맴버 수.

	const char * GetURL(){  // 길드 URL.
		return m_URL.c_str();
	}

	void GetMemberHandle( std::vector<AR_HANDLE>& vMemberlist );

	void		ResetInfo();

	const SRaidSiege & GetRaidSiege(){ // 던전 레이드/시즈 관련정보.
		return m_RaidSiege;  
	}

	// 길드원 이름으로 길드원 얻기.
	SPlayerSlot * GetPlayerByName( const char * strName );

	const int GetGuildMemberCount() const { return m_vecMemberList.size(); }
	const int GetGuildMemberLoginCount() const {
		int count = 0;
		for( size_t i = 0; i < m_vecMemberList.size(); i++ )
		{
			if (m_vecMemberList[i]->IsLogin())
				count++;
		}
		return count;
	}

	// 연합길드정보 제거.
	void ClearAlliance();

private: 

	// 연합정보.
	void SetAllianceInfo( int nAllianceID, std::string & strAllianceName, int nAllianceMemberCount, int nAllianceMasterGuildSID, std::string & strAllianceLeaderName );


private:

	std::vector< SAllianceGuild * > m_arrAllianceGuild; // 연합길드 정보.

	//---------------------
	// 추가. bintitle

	int m_nMemberCount;			// 길드 맴버 수.	
	std::string m_strNotice;	// 길드공지
	int m_bRecruitment;			// 길드원 모집 여부.
	int m_nDungeonID;			// 소유던전ID
	std::string m_URL;		    // 길드 URL

	int m_arrAuthorityClass[ E_AUTHORITY::AUTHORITY_MAX ]; // 길드 권한등급 비트플래그(권한세트).  등급단위수.
	std::vector< std::string > m_arrAuthorityClassName; // 길드 권한등급 비트플래그(권한세트).  등급명.
	//std::string m_arrAuthorityClassName[ E_AUTHORITY::AUTHORITY_MAX ]; // 길드 권한등급 비트플래그(권한세트).  등급명.

	static int m_arrRank[ 11 ];

	SRaidSiege m_RaidSiege; // 던전 레이드/시즈 관련정보.

	int m_nGrade;
	int m_nPoint;
};


//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
/// 길드 데이타
typedef struct Guild_Icon
{
	int nGuildID;
	std::string strGuildName;
	std::string strIconFileName;
	std::string strIconAniName;
	int nIconFileSize;
	bool bLoaded;
} GUILD_ICON;

/// 길드 마크, 길드 정보를 관리
class SGuildDataMgr : public SGameUIMgr
{
public:
	SGuildDataMgr();
	~SGuildDataMgr();	

	int AddMessage( const char * pMsg, int & nValue );

	bool IsExistGuild( int nGuild_id );
	bool IsLoadedGuild( int nGuild_id );

	void SendGuildData( int nGuild_ID );
	void RegistGuildData( GUILD_ICON * pGuildData );	//-N4-

	void AddGuildData( std::vector< std::string > & strGuildData );
	void DelGuildData( int nGuild_id );
	const GUILD_ICON * GetGuildData( int nGuild_id ) const;
	
	void ChangeGuildName( int nGuild_id, const char * pNewName );

	void GuildIconDownLoad();

	void Process( DWORD dwTime );

	enum
	{
		REQ_NONE = 0,
		REQ_GUILD_ICON,
	};

	enum
	{
		MODE_NONE,
		MODE_DOWNLOAD,
		MODE_DOWNLOADERROR
	};

	void SetLocalPlayer( AR_HANDLE handle ) { m_hLocalPlayer = handle; }

	void ResetInfo();
protected:

	bool IsExistGuildIconFile( const char * pGuildIconFileName );

	AR_HANDLE m_hLocalPlayer;

	static unsigned		__stdcall download_file( void* pArg );

	volatile	int	m_nMode;

	std::vector< GUILD_ICON > m_vGuildDataList;
	std::vector< GUILD_ICON > m_vDownGuildDataList;
	std::vector< GUILD_ICON > m_vWaitGuildDataList;

private:
};

class SFriendMgr : public SMessengerMgr
{
public:
	SFriendMgr();

	virtual void Clear();

	//virtual int AddMessage( const char* szMsg );
	virtual int AddMessage( const char* szMsg, bool & bSelf ); // 2010.11.29. bintitle. 메세지가 자신에게만 해당되는지 여부 반환.
	virtual void InfoMember( STR_LIST& vecText );
	
	void ChangeMemberStatus( STR_LIST& vecText );
	void		ResetInfo();
};

class SCutMgr : public SMessengerMgr
{
public:
	SCutMgr();

	virtual void Clear();

	//virtual int AddMessage( const char* szMsg );
	virtual int AddMessage( const char* szMsg, bool & bSelf ); // 2010.11.29. bintitle. 메세지가 자신에게만 해당되는지 여부 반환.
	virtual void InfoMember( STR_LIST& vecText );

	void		ResetInfo();
};