guild.cpp

墨香最新私服

// Guild.cpp: implementation of the CGuild class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Guild.h"
#include "Player.h"
#include "UserTable.h"
#include "GuildManager.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CGuild::CGuild(GUILDINFO* pInfo, MONEYTYPE GuildMoney)
{
	m_GuildInfo.GuildIdx = pInfo->GuildIdx;
	m_GuildInfo.MasterIdx = pInfo->MasterIdx;
	m_GuildInfo.MapNum = pInfo->MapNum;
	SafeStrCpy(m_GuildInfo.GuildName, pInfo->GuildName, MAX_GUILD_NAME+1);
	m_GuildInfo.UnionIdx = pInfo->UnionIdx;
	m_GuildInfo.GuildLevel = pInfo->GuildLevel;
	SafeStrCpy(m_GuildInfo.MasterName, pInfo->MasterName, MAX_NAME_LENGTH+1);
	m_MarkName = 0;
	for(int i=0; i<eRankPos_Max; ++i)
		m_RankMemberIdx[i] = 0;
	m_GuildWare.Init(GuildMoney);
}

CGuild::~CGuild()
{
	m_MemberList.RemoveAll();	
}


BOOL CGuild::IsMaster(DWORD PlayerIDX)
{
	if(m_GuildInfo.MasterIdx != PlayerIDX)
		return FALSE;
	else
		return TRUE;
}

void CGuild::BreakUp()
{
// set member info clear
	CPlayer* pPlayer = NULL;
	MSGBASE msg;
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_BREAKUP_ACK;
	
	PTRLISTPOS pos = m_MemberList.GetHeadPosition();
	GUILDMEMBERINFO* pInfo = NULL;
	while(pInfo = (GUILDMEMBERINFO*)m_MemberList.GetNext(pos))
	{
		pPlayer = (CPlayer*)g_pUserTable->FindUser(pInfo->MemberIdx);
		if(pPlayer)
		{
			pPlayer->SetGuildInfo(0, GUILD_NOTMEMBER, "", 0);
			pPlayer->SendMsg(&msg, sizeof(msg));
			GUILDMGR->MarkChange(pPlayer, 0, 0);
		}
		SAFE_DELETE(pInfo);
		
	}
	m_MemberList.RemoveAll();
}


BOOL CGuild::AddMember(GUILDMEMBERINFO* pMemberInfo)
{
	PTRLISTPOS pos = m_MemberList.GetHeadPosition();
	GUILDMEMBERINFO* pInfo = NULL;
	while(pInfo = (GUILDMEMBERINFO*)m_MemberList.GetNext(pos))
 	{
 		if(pInfo->MemberIdx == pMemberInfo->MemberIdx)
 		{
 			return FALSE;
		}
	}
	
	pInfo = new GUILDMEMBERINFO;
	pInfo->InitInfo(pMemberInfo->MemberIdx, pMemberInfo->MemberName, pMemberInfo->Memberlvl, pMemberInfo->Rank);
	m_MemberList.AddTail(pInfo);
	if(pInfo->Rank > GUILD_MEMBER)
	{
		if(pInfo->Rank == GUILD_VICEMASTER)
			m_RankMemberIdx[0] = pInfo->MemberIdx;
		else if(pInfo->Rank == GUILD_SENIOR)
		{
			int pos = IsVacancy(GUILD_SENIOR);
			if((pos <0) || (pos > eRankPos_Max))
			{
				ASSERTMSG(0, "Load GuildMemberInfo - Set Ranked Member");
				return TRUE;
			}
			m_RankMemberIdx[pos] = pInfo->MemberIdx;
		}
	}
	SendAddMsg(pInfo, pMemberInfo->MemberIdx);
	return TRUE;
}

BOOL CGuild::DeleteMember(DWORD PlayerIDX, BYTE bType)
{
	CPlayer* pPlayer = NULL;
	PTRLISTPOS pos = m_MemberList.GetHeadPosition();
	GUILDMEMBERINFO* pInfo = NULL;

	while(pos)
	{
		pInfo = (GUILDMEMBERINFO*)m_MemberList.GetAt(pos);
		if(pInfo)
		{
			if(pInfo->MemberIdx == PlayerIDX)
			{
				ResetRankMemberInfo(PlayerIDX, pInfo->Rank);
				SAFE_DELETE(pInfo);
				m_MemberList.RemoveAt(pos);
				return TRUE;
			}
		}
		m_MemberList.GetNext(pos);
	}

	return FALSE;
}

void CGuild::SendDeleteMsg(DWORD PlayerIDX, BYTE bType)
{
	MSG_DWORDBYTE msg;
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_DELETEMEMBER_ACK;
	msg.dwData = PlayerIDX;
	msg.bData = bType;
	SendMsgToAll(&msg, sizeof(msg));
}

void CGuild::SendAddMsg(GUILDMEMBERINFO* pInfo, DWORD CharacterIDX)
{
	SEND_GUILD_MEMBER_INFO msg;
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_ADDMEMBER_ACK;
	msg.GuildIdx = GetIdx();
	SafeStrCpy(msg.GuildName, GetGuildName(), MAX_GUILD_NAME+1);
	msg.MemberInfo.MemberIdx = pInfo->MemberIdx;
	SafeStrCpy(msg.MemberInfo.MemberName, pInfo->MemberName, MAX_NAME_LENGTH+1);
	msg.MemberInfo.Rank = pInfo->Rank;
	msg.MemberInfo.Memberlvl = pInfo->Memberlvl;

	SendMsgToAllExceptOne(&msg, sizeof(msg), CharacterIDX);
}

void CGuild::SendMsgToAll(MSGBASE* msg, int size)
{
	CPlayer* pPlayer = NULL;
	GUILDMEMBERINFO* pInfo = NULL;
	PTRLISTPOS pos = m_MemberList.GetHeadPosition();
	while(pInfo = (GUILDMEMBERINFO*)m_MemberList.GetNext(pos))
	{
		pPlayer = (CPlayer*)g_pUserTable->FindUser(pInfo->MemberIdx);
		if(pPlayer)
		{
			pPlayer->SendMsg(msg, size);
		}
	}
}

void CGuild::SendMsgToAllExceptOne(MSGBASE* msg, int size, DWORD CharacterIdx)
{
	CPlayer* pPlayer = NULL;
	GUILDMEMBERINFO* pInfo = NULL;
	PTRLISTPOS pos = m_MemberList.GetHeadPosition();
	while(pInfo = (GUILDMEMBERINFO*)m_MemberList.GetNext(pos))
	{
		pPlayer = (CPlayer*)g_pUserTable->FindUser(pInfo->MemberIdx);
		if(pPlayer)
		{
			if(pPlayer->GetID() == CharacterIdx)
				continue;
			pPlayer->SendMsg(msg, size);
		}
	}
}

BOOL CGuild::IsMember(DWORD MemberIDX)
{
	CPlayer* pMember = (CPlayer*)g_pUserTable->FindUser(MemberIDX);
	if(pMember)
	{
		if(pMember->GetGuildIdx() == GetIdx())
			return TRUE;
	}
	else
	{
		PTRLISTPOS pos = m_MemberList.GetHeadPosition();
		GUILDMEMBERINFO* pInfo;
		while(pInfo = (GUILDMEMBERINFO*)m_MemberList.GetNext(pos))
		{
			if(pInfo->MemberIdx == MemberIDX)
				return TRUE;
		}
	}
	return FALSE;
}

DWORD CGuild::GetIdx()
{
	return m_GuildInfo.GuildIdx;
}

void CGuild::GetTotalMember(GUILDMEMBERINFO* pRtInfo)
{
	PTRLISTPOS pos = m_MemberList.GetHeadPosition();
	GUILDMEMBERINFO* pInfo = NULL;
	int i=0;
	while(pInfo = (GUILDMEMBERINFO*)m_MemberList.GetNext(pos))
	{
		if(i == MAX_GUILDMEMBER_NUM )
			break;
		pRtInfo[i].InitInfo(pInfo->MemberIdx, pInfo->MemberName, pInfo->Memberlvl, pInfo->Rank);
		i++;
	}
}


MARKNAMETYPE CGuild::GetMarkName()
{
	return m_MarkName;
}

void CGuild::SetMarkName(MARKNAMETYPE name)
{
	m_MarkName = name;
}

BYTE CGuild::GetLevel()
{
	return m_GuildInfo.GuildLevel;
}

void CGuild::LevelUp(BYTE Level)
{
	m_GuildInfo.GuildLevel = Level;

	MSG_BYTE msg;
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_LEVELUP_ACK;
	msg.bData = m_GuildInfo.GuildLevel;
	SendMsgToAll(&msg, sizeof(msg));
}

DWORD CGuild::GetMasterIdx()
{
	return m_GuildInfo.MasterIdx;
}

BYTE CGuild::GetMaxMemberNum()
{
	if(( m_GuildInfo.GuildLevel <= 0) || ( m_GuildInfo.GuildLevel > GUILD_5LEVEL))
	{
		char buf[64];
		sprintf(buf, "Wrong Member Num, GuildIdx : %u", m_GuildInfo.GuildIdx);
		ASSERTMSG(0, buf);
		return 0;
	}
	return 10 + ( (m_GuildInfo.GuildLevel-1) * 5 ); 
}

BOOL CGuild::CanAddMember()
{	
	if( GetMemberNum() < GetMaxMemberNum() )
		return TRUE;
	else
		return FALSE;
}

BOOL CGuild::ChangeMemberRank(DWORD MemberIdx, BYTE ToRank)
{
	int rt = IsVacancy(ToRank);
	if(rt == eRankPos_Err)
		return FALSE;
	if( DoChangeMemberRank(MemberIdx, rt, ToRank) == FALSE)
		return FALSE;

	MSG_DWORDBYTE msg;
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_CHANGERANK_ACK;
	msg.dwData = MemberIdx;
	msg.bData = ToRank;
	SendMsgToAll(&msg, sizeof(MSG_DWORDBYTE));

	return TRUE;
}

int CGuild::IsVacancy(BYTE ToRank)
{
	int end = 0;
	int start = 0;
	switch(ToRank)
	{
	case GUILD_VICEMASTER:
		{
			start = 0; end = 1;
		}
		break;
	case GUILD_SENIOR:
		{
			start = 1; end = 3;
		}
		break;
	case GUILD_MEMBER:
		return eRankPos_Max;
		
	default:
		ASSERTMSG(0, "IsVancancy Err.");
		return eRankPos_Err;
	}

	BOOL rt = eRankPos_Err;
	for(int i=start; i<end; ++i)
	{
		if( m_RankMemberIdx[i] == 0 )
		{
			return i;
		}
	}
	return rt;
}

GUILDMEMBERINFO* CGuild::GetMemberInfo(DWORD MemberIdx)
{
	PTRLISTPOS pos = m_MemberList.GetHeadPosition();
	GUILDMEMBERINFO* pInfo = NULL;

	while(pos)
	{
		pInfo = (GUILDMEMBERINFO*)m_MemberList.GetAt(pos);
		if(pInfo)
		{
			if(pInfo->MemberIdx == MemberIdx)
			{
				return pInfo;
			}
		}
		m_MemberList.GetNext(pos);
	}
	char buf[64];
	sprintf(buf, "ERR, NO MemberInfo. GuildIdx: %d, MemberIdx: %d", GetIdx(), MemberIdx);
	ASSERTMSG(0, buf);
	return NULL;
}

BOOL CGuild::DoChangeMemberRank(DWORD MemberIdx, int Pos, BYTE Rank)
{
	GUILDMEMBERINFO* pMemberInfo = GetMemberInfo(MemberIdx);
	if(pMemberInfo == 0)
	{
		ASSERTMSG(0, "Change Rank - No Member Data");
		return FALSE;
	}
	if((Pos <0) || (Pos >eRankPos_Max))
	{
		ASSERTMSG(0, "change rank pos boundary error");
		return FALSE;
	}
	ResetRankMemberInfo(MemberIdx, pMemberInfo->Rank);
	pMemberInfo->Rank = Rank;
	if(Pos == eRankPos_Max)
		return TRUE;
	m_RankMemberIdx[Pos] = MemberIdx;
	return TRUE;
}

void CGuild::ResetRankMemberInfo(DWORD MemberIdx, BYTE Rank)
{
	switch(Rank)
	{
	case GUILD_VICEMASTER:
		m_RankMemberIdx[0] = 0; break;
	case GUILD_SENIOR:
		{
			if(m_RankMemberIdx[1] == MemberIdx)
				m_RankMemberIdx[1] = 0;
			else if(m_RankMemberIdx[2] == MemberIdx)
				m_RankMemberIdx[2] = 0;
			else 
				ASSERTMSG(0, "ResetRankMemberInfo() - No Rank");
		}
		break;
	}
}

void CGuild::InitGuildItem(ITEMBASE* pInfo)
{
	m_GuildWare.InitGuildItem(pInfo);
}

CItemSlot* CGuild::GetSlot()
{
	return &m_GuildWare;
}

void CGuild::EnterWareHouse(CPlayer* pPlayer,BYTE TabNum)
{
	m_GuildWare.EnterWareHouse(pPlayer, TabNum);
}

void CGuild::LeaveWareHouse(DWORD PlayerID,BYTE TabNum)
{
	m_GuildWare.LeaveWareHouse(PlayerID, TabNum);
}

MAPTYPE CGuild::GetLocation()
{
	return m_GuildInfo.MapNum;
}

MONEYTYPE CGuild::GetMaxPurseMoney()
{
	return m_GuildWare.GetMaxMoney();
}

MONEYTYPE CGuild::GetMoney()
{
	return m_GuildWare.GetMoney();
}

MONEYTYPE CGuild::SetMoney( MONEYTYPE ChangeValue, BYTE bOper, BYTE MsgFlag )
{
	return m_GuildWare.SetMoney(ChangeValue, bOper, MsgFlag);
}

void CGuild::SendtoWarehousePlayerAll(MSGBASE* msg, int size)
{
	m_GuildWare.SendtoWarehousePlayerAll(msg, size);
}