guildmanager.cpp

墨香最新私服

// GuildManager.cpp: implementation of the CGuildManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GuildManager.h"
#include "MapDBMsgParser.h"
#include "UserTable.h"
#include "Network.h"
#include "Player.h"
#include "Guild.h"
#include "..\[CC]Header\GameResourceManager.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CGuildManager::CGuildManager()
{
	m_GuildRoomHashTable.Initialize(256);
}

CGuildManager::~CGuildManager()
{
	void* pInfo;
	m_GuildRoomHashTable.SetPositionHead();
	while(pInfo = m_GuildRoomHashTable.GetData())
		delete pInfo;
	m_GuildRoomHashTable.RemoveAll();
}

void CGuildManager::NetworkMsgParse( BYTE Protocol, void* pMsg )
{
	switch(Protocol)
	{
	case MP_GUILD_CREATE_SYN:
		{
			SEND_GUILD_CREATE_SYN* pmsg = (SEND_GUILD_CREATE_SYN*)pMsg;
			CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser(pmsg->dwObjectID);
			if(pPlayer == 0)
				return;
			CreateGuildSyn(pPlayer, pmsg->GuildName, pmsg->Intro);
		}
		break;
	case MP_GUILD_BREAKUP_SYN:
		{
			MSGBASE* pmsg = (MSGBASE*)pMsg;
			CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser(pmsg->dwObjectID);
			if(pPlayer == 0)
				return;
			BreakUpGuildSyn(pPlayer);
		}
		break;
	case MP_GUILD_DELETEMEMBER_SYN:
		{
			MSG_DWORD* pmsg = (MSG_DWORD*)pMsg;
			CPlayer* pMaster = (CPlayer*)g_pUserTable->FindUser(pmsg->dwObjectID);
			if(pMaster == 0)
				return;
			DeleteMemberSyn(pMaster, pmsg->dwData);
		}
		break;
	case MP_GUILD_ADDMEMBER_SYN:
		{
			MSG_DWORD* pmsg = (MSG_DWORD*)pMsg;
			CPlayer* pMaster = (CPlayer*)g_pUserTable->FindUser(pmsg->dwObjectID);
			if(pMaster == 0)
				return;
			AddMemberSyn(pMaster, pmsg->dwData);		
		}
		break;
	case MP_GUILD_INVITE_ACCEPT:
		{
			MSG_DWORD* pmsg = (MSG_DWORD*)pMsg;
			CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser(pmsg->dwObjectID);
			if(pPlayer == 0)
				return;
			AddMemberResult(pPlayer, pmsg->dwData);
		}
		break;
	case MP_GUILD_INVITE_DENY:
		{
			MSG_DWORD* pmsg = (MSG_DWORD*)pMsg;
			CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser(pmsg->dwObjectID);
			if(pPlayer == 0)
				return;
			CPlayer* pMaster = (CPlayer*)g_pUserTable->FindUser(pmsg->dwData);
			if(pMaster == 0)
				return;
			MSGBASE msg;
			msg.Category = MP_GUILD;
			msg.Protocol = MP_GUILD_INVITE_DENY;
			pMaster->SendMsg(&msg, sizeof(msg));
		}
		break;
	case MP_GUILD_SECEDE_SYN:
		{
			MSGBASE * pmsg = (MSGBASE*)pMsg;
			CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser(pmsg->dwObjectID);
			if(pPlayer == 0)
				return;
			SecedeSyn(pPlayer);
		}
		break;
	///////////////////////////////////////////////////////////////////////////
	//NOTIFY
	case MP_GUILD_CREATE_NOTIFY_TO_MAP:
		{
			SEND_GUILD_CREATE_NOTIFY* pmsg = (SEND_GUILD_CREATE_NOTIFY*)pMsg;
			CGuild* pGuild = RegistGuild(&pmsg->GuildInfo);
			if(pGuild == 0)
				return;
			GUILDMEMBERINFO Memberinfo;
			Memberinfo.InitInfo(pmsg->GuildInfo.MasterIdx, pmsg->GuildInfo.MasterName, pmsg->MasterLvl, GUILD_MASTER);
			pGuild->AddMember(&Memberinfo);
		}
		break;
	case MP_GUILD_BREAKUP_NOTIFY_TO_MAP:
		{
			MSGBASE* pmsg = (MSGBASE*)pMsg;
			DoBreakUp(pmsg->dwObjectID);
		}
		break;
	case MP_GUILD_DELETEMEMBER_NOTIFY_TO_MAP:
		{
			MSG_DWORD* pmsg = (MSG_DWORD*)pMsg;
			DoDeleteMember(pmsg->dwObjectID, pmsg->dwData, eGuild_Delete);
		}
		break;
	case MP_GUILD_ADDMEMBER_NOTIFY_TO_MAP:
		{
			SEND_GUILD_MEMBER_INFO* pmsg = (SEND_GUILD_MEMBER_INFO*)pMsg;
			CGuild* pGuild = GetGuild(pmsg->GuildIdx);
			if(pGuild == 0)
			{
				ASSERTMSG(0, "Different Guild Info!");
				return;
			}
			GUILDMEMBERINFO member;
			member.InitInfo(pmsg->MemberInfo.MemberIdx, pmsg->MemberInfo.MemberName, pmsg->MemberInfo.Memberlvl);
			if(pGuild->AddMember(&member) == FALSE)
			{
				char buf[128];
				sprintf(buf, "Add Notify Failed! GuildIdx : %u, MemberIdx : %u", pmsg->GuildIdx, pmsg->MemberInfo.MemberIdx);
				ASSERTMSG(0, buf);
			}
		}
		break;
	case MP_GUILD_SECEDE_NOTIFY_TO_MAP:
		{
			MSG_DWORD * pmsg = (MSG_DWORD*)pMsg;
			DoDeleteMember(pmsg->dwObjectID, pmsg->dwData, eGuild_Secede);
		}
		break;
	default:
		{
			char buf[32];
			sprintf(buf, "Protocol : %d", Protocol);
			ASSERTMSG(0, buf);
		}
	}
}

CGuild* CGuildManager::RegistGuild(GUILDINFO* pGuildInfo)
{
	if(m_GuildRoomHashTable.GetData(pGuildInfo->GuildIdx))
	{
		char buf[64];
		sprintf(buf, "Error! GuildIdx : %u", pGuildInfo->GuildIdx);
		ASSERTMSG(0, buf);
		return NULL;
	}
	CGuild* pGuild = new CGuild(pGuildInfo);
	m_GuildRoomHashTable.Add(pGuild, pGuildInfo->GuildIdx);
	return pGuild;
}

void CGuildManager::CreateGuildSyn(CPlayer* pPlayer, char* GuildName, char* Intro)
{
	if(pPlayer->GetGuildIdx())
	{
		ASSERT(0);
		OnErr(pPlayer, MP_GUILD_CREATE_NACK, eGuildErr_Err);
	}
	if(pPlayer->GetLevel() < 15)
	{
		ASSERT(0);
		OnErr(pPlayer, MP_GUILD_CREATE_NACK, eGuildErr_Err);
	}
	if(IsVaildGuildName(GuildName) == FALSE)
	{
		ASSERT(0);
		OnErr(pPlayer, MP_GUILD_CREATE_NACK, eGuildErr_Create_Name);
	}
	if(strlen(Intro) > MAX_GUILD_INTRO)
	{
		ASSERT(0);
		OnErr(pPlayer, MP_GUILD_CREATE_NACK, eGuildErr_Create_Intro);
	}

	//db insert
	GuildCreate(pPlayer->GetID(), pPlayer->GetObjectName(), pPlayer->GetLevel(), GuildName, Intro);
}

void CGuildManager::CreateGuildResult(LEVELTYPE MasterLvl, GUILDINFO* pGuildInfo)
{
	CGuild* pGuild = RegistGuild(pGuildInfo);
	if(pGuild == 0)
		return;
	
	//client
	CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser(pGuildInfo->MasterIdx);
	if(pPlayer)
	{
		pPlayer->SetGuildInfo(pGuildInfo->GuildIdx, GUILD_MASTER, pGuildInfo->GuildName);
		
		//ack
		SEND_GUILD_CREATE_ACK msg;
		msg.Category = MP_GUILD;
		msg.Protocol = MP_GUILD_CREATE_ACK;
		msg.GuildIdx = pGuildInfo->GuildIdx;
		SafeStrCpy(msg.GuildName, pGuildInfo->GuildName, MAX_GUILD_NAME+1);
		pPlayer->SendMsg(&msg, sizeof(msg));
	}
	
	GUILDMEMBERINFO Memberinfo;
	Memberinfo.InitInfo(pGuildInfo->MasterIdx, pGuildInfo->MasterName, MasterLvl, GUILD_MASTER);
	pGuild->AddMember(&Memberinfo);

	//NOTIFY
	SEND_GUILD_CREATE_NOTIFY notify;
	notify.Category = MP_GUILD;
	notify.Protocol = MP_GUILD_CREATE_NOTIFY_TO_MAP;
	notify.GuildInfo.GuildIdx = pGuildInfo->GuildIdx;
	notify.GuildInfo.GuildLevel = GUILD_1LEVEL;
	SafeStrCpy(notify.GuildInfo.GuildName, pGuildInfo->GuildName, MAX_GUILD_NAME+1);
	notify.GuildInfo.MapNum = GAMERESRCMNGR->GetLoadMapNum();
	notify.GuildInfo.MasterIdx = pGuildInfo->MasterIdx;
	notify.GuildInfo.UnionIdx = 0;
	notify.MasterLvl = MasterLvl;
	
	g_Network.Send2AgentServer((char*)&notify, sizeof(notify));
}

void CGuildManager::BreakUpGuildSyn(CPlayer* pMaster)
{
	if(pMaster->GetGuildMemberRank() != GUILD_MASTER)
		OnErr(pMaster, MP_GUILD_BREAKUP_NACK, eGuildErr_BreakUp);

	DWORD GuildIdx = pMaster->GetGuildIdx();
	BYTE rt = DoBreakUp(GuildIdx);
	if(rt)
	{
		OnErr(pMaster, MP_GUILD_BREAKUP_NACK, rt);
	}

	m_GuildRoomHashTable.Remove(GuildIdx);
	
	//DB update
	GuildBreakUp(GuildIdx);

	//notify break up msg
	MSGBASE notify;
	notify.Category = MP_GUILD;
	notify.Protocol = MP_GUILD_BREAKUP_NOTIFY_TO_MAP;
	notify.dwObjectID = pMaster->GetGuildIdx();
	g_Network.Send2AgentServer((char*)&notify, sizeof(notify));
}

BYTE CGuildManager::DoBreakUp(DWORD GuildIdx)
{
	CGuild* pGuild = GetGuild(GuildIdx);
	if(!pGuild)
	{
		ASSERT(0);
		return eGuildErr_BreakUp; 
	}

	//set member clear guildinfo 
	pGuild->BreakUp();
	return 0;
}

CGuild* CGuildManager::GetGuild(DWORD GuildIdx)
{
	CGuild * pInfo = NULL;
	pInfo = m_GuildRoomHashTable.GetData(GuildIdx);
	return pInfo;
}

void CGuildManager::SendNackMsg(CPlayer* pPlayer, BYTE Protocol, BYTE errstate)
{
	MSG_BYTE nmsg;
	nmsg.Category = MP_GUILD;
	nmsg.Protocol = Protocol;
	nmsg.bData = errstate;
	pPlayer->SendMsg(&nmsg, sizeof(nmsg));
}

BOOL CGuildManager::IsVaildGuildName(char* GuildName)
{
	CGuild * pInfo;
	m_GuildRoomHashTable.SetPositionHead();
	while(pInfo = m_GuildRoomHashTable.GetData())
	{
		if(strcmp(pInfo->GetGuildName(), GuildName) == 0)
			return FALSE;
	}
	if(strlen(GuildName) > MAX_GUILD_NAME)
		return FALSE;
	return TRUE;
}

void CGuildManager::DeleteMemberSyn(CPlayer* pMaster, DWORD MemberIDX)
{
	DWORD GuildIdx = pMaster->GetGuildIdx();
	BYTE err = DoDeleteMember(GuildIdx, MemberIDX, eGuild_Delete);
	if(err)
	{
		OnErr(pMaster, MP_GUILD_DELETEMEMBER_NACK, err);
	}
	
	//db update
	GuildDeleteMember(GuildIdx, MemberIDX);

	//notify 
	MSG_DWORD notify;
	notify.Category = MP_GUILD;
	notify.Protocol = MP_GUILD_DELETEMEMBER_NOTIFY_TO_MAP;
	notify.dwObjectID = GuildIdx;
	notify.dwData = MemberIDX;
	g_Network.Send2AgentServer((char*)&notify, sizeof(notify));	
}

BYTE CGuildManager::DoDeleteMember(DWORD GuildIDX, DWORD MemberIDX, BYTE bType)
{
	CGuild* pGuild = m_GuildRoomHashTable.GetData(GuildIDX);
	if(pGuild == 0)
	{
		ASSERT(0);
		return eGuildErr_Err;
	}
	if(pGuild->IsMember(MemberIDX) == FALSE)
	{
		ASSERT(0);
		return eGuildErr_DeleteMember;
	}

	//member delete
	if(pGuild->DeleteMember(MemberIDX, bType) == FALSE)
	{
		ASSERT(0);
		return eGuildErr_Err;
	}	

	//TO DO 龋莫档 昏力 眠啊
	CPlayer* pMember = (CPlayer*)g_pUserTable->FindUser(MemberIDX);
	if(pMember)
	{
		pMember->SetGuildInfo(0, GUILD_NOTMEMBER, "");
	}
	return 0;
}

void CGuildManager::LoadMembers(GUILDMEMBERINFO_ID* pInfo)
{
	CGuild * pGuild = GetGuild(pInfo->GuildIdx);
	if(pGuild == 0)
	{
		char buf[64];
		sprintf(buf, "GuildIdx : %d, CharacterIdx : %d", pInfo->GuildIdx, pInfo->MemberInfo.MemberIdx);
		ASSERTMSG(0, buf);
		return;
	}
	pGuild->AddMember(&pInfo->MemberInfo);
}

void CGuildManager::AddMemberSyn(CPlayer* pMaster, DWORD TargetIdx)
{
	CPlayer* pTarget = (CPlayer*)g_pUserTable->FindUser(TargetIdx);
	if(pTarget == 0)
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_AddMember_NotPlayer);
	if(pTarget->GetGuildIdx())
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_AddMember_OtherGuild);
	
	CGuild* pGuild = GetGuild(pMaster->GetGuildIdx());
	if(pGuild == 0)
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_Err);
	if(pGuild->IsMember(TargetIdx) == TRUE)
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_AddMember_AlreadyMember);

	MSGBASE msg;
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_ADDMEMBER_INVITE;
	pMaster->SendMsg(&msg, sizeof(msg));

	SEND_GUILD_INVITE invite;
	invite.Category = MP_GUILD;
	invite.Protocol = MP_GUILD_INVITE;
	invite.MasterIdx = pMaster->GetID();
	SafeStrCpy(invite.MasterName, pMaster->GetObjectName(), MAX_NAME_LENGTH+1);
	SafeStrCpy(invite.GuildName, pGuild->GetGuildName(), MAX_GUILD_NAME+1);
	pTarget->SendMsg(&invite, sizeof(invite));
}

void CGuildManager::AddMemberResult(CPlayer* pTarget, DWORD MasterIdx)
{
	CPlayer* pMaster = (CPlayer*)g_pUserTable->FindUser(MasterIdx);
	if(pMaster == 0)
		OnErr(pTarget, MP_GUILD_INVITE_ACCEPT_NACK, eGuildErr_InviteApt_NoMaster);
	
	CGuild* pGuild = GetGuild(pMaster->GetGuildIdx());
	if(pGuild == 0)
		OnErr(pTarget, MP_GUILD_INVITE_ACCEPT_NACK, eGuildErr_Err);
	
	if(pGuild->IsMember(pTarget->GetID()) == TRUE)
		OnErr(pTarget, MP_GUILD_INVITE_ACCEPT_NACK, eGuildErr_Err);
	//db update
	GuildAddMember(pMaster->GetGuildIdx(), pTarget->GetID(), pGuild->GetGuildName(), GUILD_MEMBER);

	pTarget->SetGuildInfo(pMaster->GetGuildIdx(), GUILD_MEMBER, pGuild->GetGuildName());
	GUILDMEMBERINFO member;
	member.InitInfo(pTarget->GetID(), pTarget->GetObjectName(), pTarget->GetLevel());
	pGuild->AddMember(&member);

	SEND_GUILD_TOTALINFO tmsg;
	memset(&tmsg, 0, sizeof(SEND_GUILD_TOTALINFO));
	tmsg.Category = MP_GUILD;
	tmsg.Protocol = MP_GUILD_ACCEPT_ACK;
	tmsg.InitGuildInfo(pGuild->GetGuildInfo());
	pGuild->GetTotalMember(tmsg.MemberInfo);
	tmsg.membernum = pGuild->GetMemberNum();
	pTarget->SendMsg(&tmsg, tmsg.GetMsgLength());

	//notify
	SEND_GUILD_MEMBER_INFO notify;
	notify.Category = MP_GUILD;
	notify.Protocol = MP_GUILD_ADDMEMBER_NOTIFY_TO_MAP;
	notify.GuildIdx = pMaster->GetGuildIdx();
	SafeStrCpy(notify.GuildName, pGuild->GetGuildName(), MAX_GUILD_NAME+1);
	notify.MemberInfo.MemberIdx = pTarget->GetID();
	notify.MemberInfo.Memberlvl = pTarget->GetLevel();
	SafeStrCpy(notify.MemberInfo.MemberName, pTarget->GetObjectName(), MAX_NAME_LENGTH+1);
	notify.MemberInfo.Rank = GUILD_MEMBER;
	g_Network.Send2AgentServer((char*)&notify, sizeof(notify));
}

void CGuildManager::UserLogIn(CPlayer* pPlayer)
{
	if(pPlayer->GetGuildIdx() == 0)
		return;
	
	CGuild* pGuild = GetGuild(pPlayer->GetGuildIdx());
	if(pGuild == 0)
	{
		ASSERTMSG(0, "UserLogIn - No Guild Info! ");
		return;
	}
	
	SEND_GUILD_TOTALINFO msg;
	memset(&msg, 0, sizeof(SEND_GUILD_TOTALINFO));
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_INFO;
	msg.InitGuildInfo(pGuild->GetGuildInfo());
	pGuild->GetTotalMember(msg.MemberInfo);
	
	msg.membernum = pGuild->GetMemberNum();
	
	pPlayer->SendMsg(&msg, msg.GetMsgLength());
}

void CGuildManager::SecedeSyn(CPlayer* pPlayer)
{
	DWORD GuildIdx = pPlayer->GetGuildIdx();
	CGuild* pGuild = GetGuild(GuildIdx);
	if(pGuild == 0)
	{
		char buf[64];
		sprintf(buf, "characterIdx : %d", pPlayer->GetID());
		ASSERTMSG(0, buf);
		OnErr(pPlayer, MP_GUILD_SECEDE_NACK, eGuildErr_Secede_NoGuild);
	}
	if(pPlayer->GetGuildMemberRank() >= GUILD_MASTER)
	{
		OnErr(pPlayer, MP_GUILD_SECEDE_NACK, eGuildErr_Err);
	}
	//db update
	GuildDeleteMember(GuildIdx, pPlayer->GetID());

	pPlayer->SetGuildInfo(0, GUILD_NOTMEMBER, "");

	MSGBASE msg;
	msg.Category = MP_GUILD;
	msg.Protocol = MP_GUILD_SECEDE_ACK;
	pPlayer->SendMsg(&msg, sizeof(msg));

	BOOL rt = pGuild->DeleteMember(pPlayer->GetID(), eGuild_Secede);
	if(rt == FALSE)
		return;	

	pGuild->SendDeleteMsg(pPlayer->GetID(), eGuild_Secede);
	
	//notify
	MSG_DWORD notify;
	notify.Category = MP_GUILD;
	notify.Protocol = MP_GUILD_SECEDE_NOTIFY_TO_MAP;
	notify.dwObjectID = GuildIdx;
	notify.dwData = pPlayer->GetID();
	g_Network.Send2AgentServer((char*)&notify, sizeof(notify));
}