guildmanager.cpp

墨香最新私服

void CGuildManager::BreakUpGuildResult(CPlayer* pMaster, DWORD GuildIdx, char* EntryDate)
{
	BYTE rt = DoBreakUp(GuildIdx);
	if(rt)
	{
		if(pMaster == 0)
			return;
		OnErr(pMaster, MP_GUILD_BREAKUP_NACK, rt);
	}
	
	m_GuildRoomHashTable.Remove(GuildIdx);

	if(pMaster)
	{
		EXPTYPE pointForLevel = GAMERESRCMNGR->GetMaxExpPoint(pMaster->GetLevel());
		EXPTYPE minusExp = (EXPTYPE)(pointForLevel * 0.2);
		pMaster->ReduceExpPoint(minusExp, eExpLog_LosebyBreakupGuild);
		
		SendGuildEntryDate(pMaster, EntryDate);
	}

	//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; 
	}

	DeleteMark(pGuild->GetMarkName());
	//set member clear guildinfo 
	pGuild->BreakUp();

	return 0;
}

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

CGuildMark* CGuildManager::GetMark(MARKNAMETYPE MarkName)
{
	CGuildMark* pMark = NULL;
	pMark = m_GuildMarkTable.GetData(MarkName);
	return pMark;
}

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)
{
	//db update
	GuildDeleteMember(pMaster->GetGuildIdx(), MemberIDX);
}

void CGuildManager::DeleteMemberResult(DWORD GuildIdx, DWORD MemberIDX, char* EntryDay)
{
	CGuild* pGuild = GetGuild(GuildIdx);
	if(pGuild == 0)
		return;

	BYTE err = DoDeleteMember(GuildIdx, MemberIDX, eGuild_Delete, EntryDay);
	if(err)
	{
		ASSERT(0);
		CPlayer* pMaster = (CPlayer*)g_pUserTable->FindUser(pGuild->GetMasterIdx());
		if(pMaster == 0)
			return;
		OnErr(pMaster, MP_GUILD_DELETEMEMBER_NACK, err);
	}
	
	//notify 
	MSG_NAME_DWORD notify;
	notify.Category = MP_GUILD;
	notify.Protocol = MP_GUILD_DELETEMEMBER_NOTIFY_TO_MAP;
	notify.dwObjectID = GuildIdx;
	notify.dwData = MemberIDX;
	SafeStrCpy(notify.Name, EntryDay, 11);
	g_Network.Send2AgentServer((char*)&notify, sizeof(notify));	
}

BYTE CGuildManager::DoDeleteMember(DWORD GuildIDX, DWORD MemberIDX, BYTE bType, char* EntryDay)
{
	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, "", 0);
		SendGuildEntryDate(pMember, EntryDay);			
		MSG_DWORDBYTE msg;
		msg.Category = MP_GUILD;
		msg.Protocol = MP_GUILD_DELETEMEMBER_ACK;
		msg.dwData = MemberIDX;
		msg.bData = eGuild_Delete;
		pMember->SendMsg(&msg, sizeof(msg));

		MarkChange(pMember, 0, 0);
	}
	
	pGuild->SendDeleteMsg(MemberIDX, eGuild_Delete);
	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::LoadMark(MARKNAMETYPE MarkName, char* pImgData)
{
	if(m_GuildMarkTable.GetData(MarkName))
	{
		ASSERTMSG(0, "LoadMark");
		return;
	}
	char Img[GUILDMARK_BUFSIZE];
	char *pStr = (char*)pImgData;
	char tempBuf[3] = {0,};
	int curpos = 0;
	for(int n=0;n<GUILDMARK_BUFSIZE;++n)
	{
		strncpy(tempBuf,&pStr[curpos],2); // "FF"
		Img[n] = HexToByte(tempBuf);
		curpos += 2;
	}
	CGuildMark* pMark = new CGuildMark;
	pMark->Init(MarkName, Img);
	
	m_GuildMarkTable.Add(pMark, MarkName);
}

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(pMaster->GetGuildMemberRank() < GUILD_VICEMASTER)
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_AddMember_NothaveAuthority);
	if(pGuild->IsMember(TargetIdx) == TRUE)
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_AddMember_AlreadyMember);
	if(pGuild->CanAddMember() == FALSE)
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_AddMember_FullMember);
	if(CanEntryGuild(pTarget->GetGuildCanEntryDate()) == FALSE)
		OnErr(pMaster, MP_GUILD_ADDMEMBER_NACK, eGuildErr_AddMember_TargetNotDay);

	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);

	if(pGuild->CanAddMember() == FALSE)
		OnErr(pMaster, MP_GUILD_INVITE_ACCEPT_NACK, eGuildErr_AddMember_FullMember);

	//db update
	GuildAddMember(pMaster->GetGuildIdx(), pTarget->GetID(), pGuild->GetGuildName(), GUILD_MEMBER);

	pTarget->SetGuildInfo(pMaster->GetGuildIdx(), GUILD_MEMBER, pGuild->GetGuildName(), pGuild->GetMarkName());
	MarkChange(pTarget, pMaster->GetGuildIdx(), pGuild->GetMarkName());

	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());

	MarkChange(pTarget, pMaster->GetGuildIdx(), pGuild->GetMarkName());

	//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)
	{
		OnErr(pPlayer, MP_GUILD_SECEDE_NACK, eGuildErr_NoGuild);
	}
	if(pPlayer->GetGuildMemberRank() >= GUILD_MASTER)
	{
		OnErr(pPlayer, MP_GUILD_SECEDE_NACK, eGuildErr_Err);
	}
	//db update
//	GuildDeleteMember(GuildIdx, pPlayer->GetID());
	GuildSecedeMember(GuildIdx, pPlayer->GetID());
}

void CGuildManager::SecedeResult(DWORD GuildIdx, DWORD MemberIDX, char* EntryDay)
{
	CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser(MemberIDX);
	pPlayer->SetGuildInfo(0, GUILD_NOTMEMBER, "", 0);
	SendGuildEntryDate(pPlayer, EntryDay);
	MarkChange(pPlayer, 0, 0);

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

	CGuild* pGuild = GetGuild(GuildIdx);
	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));
}

void CGuildManager::SendChatMsg(DWORD GuildIdx, DWORD PlayerIdx, char* pMsg)
{
	CGuild* pGuild = GetGuild(GuildIdx);
	if(pGuild == 0)
		return;

	TESTMSGID msg;
	msg.Category = MP_CHAT;
	msg.Protocol = MP_CHAT_GUILD;
	msg.dwSenderID = PlayerIdx;
	SafeStrCpy(msg.Msg, pMsg, MAX_CHAT_LENGTH+1);
	
	pGuild->SendMsgToAll(&msg, msg.GetMsgLength());
	
}

void CGuildManager::RegistMarkSyn(DWORD GuildIdx, char* ImgData, DWORD PlayerIdx)
{	
	GuildMarkRegist(GuildIdx, ImgData, PlayerIdx);
}

void CGuildManager::RegistMarkResult(CPlayer* pPlayer, DWORD GuildIdx, MARKNAMETYPE MarkName, char * pImgData)
{	
	CGuild* pGuild = GetGuild(GuildIdx);
	if(pGuild == 0)
		return;
	pPlayer->SetGuildMarkName(MarkName);

	MSG_GUILDMARK_IMG msg;
	char *pStr = (char*)pImgData;
	char tempBuf[3] = {0,};
	int curpos = 0;
	for(int n=0;n<GUILDMARK_BUFSIZE;++n)
	{
		strncpy(tempBuf,&pStr[curpos],2); // "FF"
		msg.imgData[n] = HexToByte(tempBuf);
		curpos += 2;
	}
	
	MarkChange(pPlayer, GuildIdx, MarkName);

	DoRegistMark(pGuild, MarkName, msg.imgData);
	msg.Category = MP_GUILD;
	msg.GuildIdx = GuildIdx;
	msg.MarkName = MarkName;
	msg.Protocol = MP_GUILDMARK_NOTIFY_TO_MAP;
	g_Network.Send2AgentServer((char*)&msg, sizeof(msg));
}

void CGuildManager::DoRegistMark(CGuild* pGuild, MARKNAMETYPE MarkName, char* imgData)