2141 lines
57 KiB
C++
2141 lines
57 KiB
C++
#include "stdafx.h"
|
||
#include "utils.h"
|
||
#include "config.h"
|
||
#include "char.h"
|
||
#include "packet.h"
|
||
#include "desc_client.h"
|
||
#include "buffer_manager.h"
|
||
#include "char_manager.h"
|
||
#include "db.h"
|
||
#include "guild.h"
|
||
#include "guild_manager.h"
|
||
#include "affect.h"
|
||
#include "p2p.h"
|
||
#include "questmanager.h"
|
||
#include "building.h"
|
||
#include "locale_service.h"
|
||
#include "log.h"
|
||
#include "questmanager.h"
|
||
|
||
SGuildMember::SGuildMember(LPCHARACTER ch, BYTE grade, DWORD offer_exp)
|
||
: pid(ch->GetPlayerID()), grade(grade), is_general(0), job(ch->GetJob()), level(ch->GetLevel()), offer_exp(offer_exp), name(ch->GetName())
|
||
{}
|
||
SGuildMember::SGuildMember(DWORD pid, BYTE grade, BYTE is_general, BYTE job, BYTE level, DWORD offer_exp, char* name)
|
||
: pid(pid), grade(grade), is_general(is_general), job(job), level(level), offer_exp(offer_exp), name(name)
|
||
{}
|
||
|
||
namespace
|
||
{
|
||
struct FGuildNameSender
|
||
{
|
||
FGuildNameSender(DWORD id, const char* guild_name) : id(id), name(guild_name)
|
||
{
|
||
p.header = HEADER_GC_GUILD;
|
||
p.subheader = GUILD_SUBHEADER_GC_GUILD_NAME;
|
||
p.size = sizeof(p) + sizeof(DWORD) + GUILD_NAME_MAX_LEN;
|
||
}
|
||
|
||
void operator() (LPCHARACTER ch)
|
||
{
|
||
LPDESC d = ch->GetDesc();
|
||
|
||
if (d)
|
||
{
|
||
d->RawPacket(&p, sizeof(p));
|
||
d->RawPacket(&id, sizeof(id));
|
||
d->Packet(name, GUILD_NAME_MAX_LEN);
|
||
}
|
||
}
|
||
|
||
DWORD id;
|
||
const char * name;
|
||
TPacketGCGuild p;
|
||
};
|
||
}
|
||
|
||
CGuild::CGuild(TGuildCreateParameter & cp)
|
||
{
|
||
Initialize();
|
||
|
||
m_general_count = 0;
|
||
|
||
m_iMemberCountBonus = 0;
|
||
|
||
strlcpy(m_data.name, cp.name, sizeof(m_data.name));
|
||
m_data.master_pid = cp.master->GetPlayerID();
|
||
strlcpy(m_data.grade_array[0].grade_name, LC_TEXT("\xB1\xE6\xB5\xE5\xC0\xE5"), sizeof(m_data.grade_array[0].grade_name));
|
||
m_data.grade_array[0].auth_flag = GUILD_AUTH_ADD_MEMBER | GUILD_AUTH_REMOVE_MEMBER | GUILD_AUTH_NOTICE | GUILD_AUTH_USE_SKILL;
|
||
|
||
for (int i = 1; i < GUILD_GRADE_COUNT; ++i)
|
||
{
|
||
strlcpy(m_data.grade_array[i].grade_name, LC_TEXT("\xB1\xE6\xB5\xE5\xBF\xF8"), sizeof(m_data.grade_array[i].grade_name));
|
||
m_data.grade_array[i].auth_flag = 0;
|
||
}
|
||
|
||
std::unique_ptr<SQLMsg> pmsg (DBManager::instance().DirectQuery(
|
||
"INSERT INTO guild%s(name, master, sp, level, exp, skill_point, skill) "
|
||
"VALUES('%s', %u, 1000, 1, 0, 0, '\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0')",
|
||
get_table_postfix(), m_data.name, m_data.master_pid));
|
||
|
||
// TODO if error occur?
|
||
m_data.guild_id = pmsg->Get()->uiInsertID;
|
||
|
||
for (int i = 0; i < GUILD_GRADE_COUNT; ++i)
|
||
{
|
||
DBManager::instance().Query("INSERT INTO guild_grade%s VALUES(%u, %d, '%s', %d)",
|
||
get_table_postfix(),
|
||
m_data.guild_id,
|
||
i + 1,
|
||
m_data.grade_array[i].grade_name,
|
||
m_data.grade_array[i].auth_flag);
|
||
}
|
||
|
||
ComputeGuildPoints();
|
||
m_data.power = m_data.max_power;
|
||
m_data.ladder_point = 0;
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_CREATE, 0, &m_data.guild_id, sizeof(DWORD));
|
||
|
||
TPacketGuildSkillUpdate guild_skill;
|
||
guild_skill.guild_id = m_data.guild_id;
|
||
guild_skill.amount = 0;
|
||
guild_skill.skill_point = 0;
|
||
memset(guild_skill.skill_levels, 0, GUILD_SKILL_COUNT);
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_SKILL_UPDATE, 0, &guild_skill, sizeof(guild_skill));
|
||
|
||
// TODO GUILD_NAME
|
||
CHARACTER_MANAGER::instance().for_each_pc(FGuildNameSender(GetID(), GetName()));
|
||
/*
|
||
TPacketDGGuildMember p;
|
||
memset(&p, 0, sizeof(p));
|
||
p.dwPID = cp.master->GetPlayerID();
|
||
p.bGrade = 15;
|
||
AddMember(&p);
|
||
*/
|
||
RequestAddMember(cp.master, GUILD_LEADER_GRADE);
|
||
}
|
||
|
||
void CGuild::Initialize()
|
||
{
|
||
memset(&m_data, 0, sizeof(m_data));
|
||
m_data.level = 1;
|
||
|
||
for (int i = 0; i < GUILD_SKILL_COUNT; ++i)
|
||
abSkillUsable[i] = true;
|
||
|
||
m_iMemberCountBonus = 0;
|
||
}
|
||
|
||
CGuild::~CGuild()
|
||
{
|
||
}
|
||
|
||
void CGuild::RequestAddMember(LPCHARACTER ch, int grade)
|
||
{
|
||
if (ch->GetGuild())
|
||
return;
|
||
|
||
TPacketGDGuildAddMember gd;
|
||
|
||
if (m_member.find(ch->GetPlayerID()) != m_member.end())
|
||
{
|
||
SPDLOG_ERROR("Already a member in guild {}[{}]", ch->GetName(), ch->GetPlayerID());
|
||
return;
|
||
}
|
||
|
||
gd.dwPID = ch->GetPlayerID();
|
||
gd.dwGuild = GetID();
|
||
gd.bGrade = grade;
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_ADD_MEMBER, 0, &gd, sizeof(TPacketGDGuildAddMember));
|
||
}
|
||
|
||
void CGuild::AddMember(TPacketDGGuildMember * p)
|
||
{
|
||
TGuildMemberContainer::iterator it;
|
||
|
||
if ((it = m_member.find(p->dwPID)) == m_member.end())
|
||
m_member.insert(std::make_pair(p->dwPID, TGuildMember(p->dwPID, p->bGrade, p->isGeneral, p->bJob, p->bLevel, p->dwOffer, p->szName)));
|
||
else
|
||
{
|
||
TGuildMember & r_gm = it->second;
|
||
r_gm.pid = p->dwPID;
|
||
r_gm.grade = p->bGrade;
|
||
r_gm.job = p->bJob;
|
||
r_gm.offer_exp = p->dwOffer;
|
||
r_gm.is_general = p->isGeneral;
|
||
}
|
||
|
||
CGuildManager::instance().Link(p->dwPID, this);
|
||
|
||
SendListOneToAll(p->dwPID);
|
||
|
||
LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(p->dwPID);
|
||
|
||
SPDLOG_DEBUG("GUILD: AddMember PID {}, grade {}, job {}, level {}, offer {}, name {} ptr {}",
|
||
p->dwPID, p->bGrade, p->bJob, p->bLevel, p->dwOffer, p->szName, (void*) get_pointer(ch));
|
||
|
||
if (ch)
|
||
LoginMember(ch);
|
||
else
|
||
P2PLoginMember(p->dwPID);
|
||
}
|
||
|
||
bool CGuild::RequestRemoveMember(DWORD pid)
|
||
{
|
||
TGuildMemberContainer::iterator it;
|
||
|
||
if ((it = m_member.find(pid)) == m_member.end())
|
||
return false;
|
||
|
||
if (it->second.grade == GUILD_LEADER_GRADE)
|
||
return false;
|
||
|
||
TPacketGuild gd_guild;
|
||
|
||
gd_guild.dwGuild = GetID();
|
||
gd_guild.dwInfo = pid;
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_REMOVE_MEMBER, 0, &gd_guild, sizeof(TPacketGuild));
|
||
return true;
|
||
}
|
||
|
||
bool CGuild::RemoveMember(DWORD pid)
|
||
{
|
||
SPDLOG_DEBUG("Receive Guild P2P RemoveMember");
|
||
TGuildMemberContainer::iterator it;
|
||
|
||
if ((it = m_member.find(pid)) == m_member.end())
|
||
return false;
|
||
|
||
if (it->second.grade == GUILD_LEADER_GRADE)
|
||
return false;
|
||
|
||
if (it->second.is_general)
|
||
m_general_count--;
|
||
|
||
m_member.erase(it);
|
||
SendOnlineRemoveOnePacket(pid);
|
||
|
||
CGuildManager::instance().Unlink(pid);
|
||
|
||
LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(pid);
|
||
|
||
if (ch)
|
||
{
|
||
//GuildRemoveAffect(ch);
|
||
m_memberOnline.erase(ch);
|
||
ch->SetGuild(NULL);
|
||
}
|
||
|
||
if ( LC_IsBrazil() == true )
|
||
{
|
||
DBManager::instance().Query("REPLACE INTO guild_invite_limit VALUES(%d, %d)", GetID(), get_global_time());
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
void CGuild::P2PLoginMember(DWORD pid)
|
||
{
|
||
if (m_member.find(pid) == m_member.end())
|
||
{
|
||
SPDLOG_ERROR("GUILD [{}] is not a memeber of guild.", pid);
|
||
return;
|
||
}
|
||
|
||
m_memberP2POnline.insert(pid);
|
||
|
||
// Login event occur + Send List
|
||
TGuildMemberOnlineContainer::iterator it;
|
||
|
||
for (it = m_memberOnline.begin(); it!=m_memberOnline.end();++it)
|
||
SendLoginPacket(*it, pid);
|
||
}
|
||
|
||
void CGuild::LoginMember(LPCHARACTER ch)
|
||
{
|
||
if (m_member.find(ch->GetPlayerID()) == m_member.end())
|
||
{
|
||
SPDLOG_ERROR("GUILD {}[{}] is not a memeber of guild.", ch->GetName(), ch->GetPlayerID());
|
||
return;
|
||
}
|
||
|
||
ch->SetGuild(this);
|
||
|
||
// Login event occur + Send List
|
||
TGuildMemberOnlineContainer::iterator it;
|
||
|
||
for (it = m_memberOnline.begin(); it!=m_memberOnline.end();++it)
|
||
SendLoginPacket(*it, ch);
|
||
|
||
m_memberOnline.insert(ch);
|
||
|
||
SendAllGradePacket(ch);
|
||
SendGuildInfoPacket(ch);
|
||
SendListPacket(ch);
|
||
SendSkillInfoPacket(ch);
|
||
SendEnemyGuild(ch);
|
||
|
||
//GuildUpdateAffect(ch);
|
||
}
|
||
|
||
void CGuild::P2PLogoutMember(DWORD pid)
|
||
{
|
||
if (m_member.find(pid)==m_member.end())
|
||
{
|
||
SPDLOG_ERROR("GUILD [{}] is not a memeber of guild.", pid);
|
||
return;
|
||
}
|
||
|
||
m_memberP2POnline.erase(pid);
|
||
|
||
// Logout event occur
|
||
TGuildMemberOnlineContainer::iterator it;
|
||
for (it = m_memberOnline.begin(); it!=m_memberOnline.end();++it)
|
||
{
|
||
SendLogoutPacket(*it, pid);
|
||
}
|
||
}
|
||
|
||
void CGuild::LogoutMember(LPCHARACTER ch)
|
||
{
|
||
if (m_member.find(ch->GetPlayerID())==m_member.end())
|
||
{
|
||
SPDLOG_ERROR("GUILD {}[{}] is not a memeber of guild.", ch->GetName(), ch->GetPlayerID());
|
||
return;
|
||
}
|
||
|
||
//GuildRemoveAffect(ch);
|
||
|
||
//ch->SetGuild(NULL);
|
||
m_memberOnline.erase(ch);
|
||
|
||
// Logout event occur
|
||
TGuildMemberOnlineContainer::iterator it;
|
||
for (it = m_memberOnline.begin(); it!=m_memberOnline.end();++it)
|
||
{
|
||
SendLogoutPacket(*it, ch);
|
||
}
|
||
}
|
||
|
||
void CGuild::SendOnlineRemoveOnePacket(DWORD pid)
|
||
{
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+4;
|
||
pack.subheader = GUILD_SUBHEADER_GC_REMOVE;
|
||
|
||
TEMP_BUFFER buf;
|
||
buf.write(&pack,sizeof(pack));
|
||
buf.write(&pid, sizeof(pid));
|
||
|
||
TGuildMemberOnlineContainer::iterator it;
|
||
|
||
for (it = m_memberOnline.begin(); it!=m_memberOnline.end();++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
|
||
if (d)
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
}
|
||
|
||
void CGuild::SendAllGradePacket(LPCHARACTER ch)
|
||
{
|
||
LPDESC d = ch->GetDesc();
|
||
if (!d)
|
||
return;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+1+GUILD_GRADE_COUNT*(sizeof(TGuildGrade)+1);
|
||
pack.subheader = GUILD_SUBHEADER_GC_GRADE;
|
||
|
||
TEMP_BUFFER buf;
|
||
|
||
buf.write(&pack, sizeof(pack));
|
||
BYTE n = 15;
|
||
buf.write(&n, 1);
|
||
|
||
for (int i=0;i<GUILD_GRADE_COUNT;i++)
|
||
{
|
||
BYTE j = i+1;
|
||
buf.write(&j, 1);
|
||
buf.write(&m_data.grade_array[i], sizeof(TGuildGrade));
|
||
}
|
||
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
|
||
void CGuild::SendListOneToAll(LPCHARACTER ch)
|
||
{
|
||
SendListOneToAll(ch->GetPlayerID());
|
||
}
|
||
|
||
void CGuild::SendListOneToAll(DWORD pid)
|
||
{
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(TPacketGCGuild);
|
||
pack.subheader = GUILD_SUBHEADER_GC_LIST;
|
||
|
||
pack.size += sizeof(TGuildMemberPacketData);
|
||
|
||
char c[CHARACTER_NAME_MAX_LEN+1];
|
||
memset(c, 0, sizeof(c));
|
||
|
||
TGuildMemberContainer::iterator cit = m_member.find(pid);
|
||
if (cit == m_member.end())
|
||
return;
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it!= m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
if (!d)
|
||
continue;
|
||
|
||
TEMP_BUFFER buf;
|
||
|
||
buf.write(&pack, sizeof(pack));
|
||
|
||
cit->second._dummy = 1;
|
||
|
||
buf.write(&(cit->second), sizeof(DWORD) * 3 +1);
|
||
buf.write(cit->second.name.c_str(), cit->second.name.length());
|
||
buf.write(c, CHARACTER_NAME_MAX_LEN + 1 - cit->second.name.length());
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
}
|
||
|
||
void CGuild::SendListPacket(LPCHARACTER ch)
|
||
{
|
||
/*
|
||
List Packet
|
||
|
||
Header
|
||
Count (byte)
|
||
[
|
||
...
|
||
name_flag 1 - <20≯<EFBFBD><CCB8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ⱥ<EFBFBD><C8BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
name CHARACTER_NAME_MAX_LEN+1
|
||
] * Count
|
||
|
||
*/
|
||
LPDESC d;
|
||
if (!(d=ch->GetDesc()))
|
||
return;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(TPacketGCGuild);
|
||
pack.subheader = GUILD_SUBHEADER_GC_LIST;
|
||
|
||
pack.size += sizeof(TGuildMemberPacketData) * m_member.size();
|
||
|
||
TEMP_BUFFER buf;
|
||
|
||
buf.write(&pack,sizeof(pack));
|
||
|
||
char c[CHARACTER_NAME_MAX_LEN+1];
|
||
|
||
for (TGuildMemberContainer::iterator it = m_member.begin(); it != m_member.end(); ++it)
|
||
{
|
||
it->second._dummy = 1;
|
||
|
||
buf.write(&(it->second), sizeof(DWORD)*3+1);
|
||
|
||
strlcpy(c, it->second.name.c_str(), std::min(sizeof(c), it->second.name.length() + 1));
|
||
|
||
buf.write(c, CHARACTER_NAME_MAX_LEN+1 );
|
||
|
||
SPDLOG_TRACE("name {} job {} ", it->second.name.c_str(), it->second.job );
|
||
}
|
||
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
SendLoginPacket(ch, *it);
|
||
}
|
||
|
||
for (TGuildMemberP2POnlineContainer::iterator it = m_memberP2POnline.begin(); it != m_memberP2POnline.end(); ++it)
|
||
{
|
||
SendLoginPacket(ch, *it);
|
||
}
|
||
|
||
}
|
||
|
||
void CGuild::SendLoginPacket(LPCHARACTER ch, LPCHARACTER chLogin)
|
||
{
|
||
SendLoginPacket(ch, chLogin->GetPlayerID());
|
||
}
|
||
|
||
void CGuild::SendLoginPacket(LPCHARACTER ch, DWORD pid)
|
||
{
|
||
/*
|
||
Login Packet
|
||
header 4
|
||
pid 4
|
||
*/
|
||
if (!ch->GetDesc())
|
||
return;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+4;
|
||
pack.subheader = GUILD_SUBHEADER_GC_LOGIN;
|
||
|
||
TEMP_BUFFER buf;
|
||
|
||
buf.write(&pack, sizeof(pack));
|
||
|
||
buf.write(&pid, 4);
|
||
|
||
ch->GetDesc()->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
|
||
void CGuild::SendLogoutPacket(LPCHARACTER ch, LPCHARACTER chLogout)
|
||
{
|
||
SendLogoutPacket(ch, chLogout->GetPlayerID());
|
||
}
|
||
|
||
void CGuild::SendLogoutPacket(LPCHARACTER ch, DWORD pid)
|
||
{
|
||
/*
|
||
Logout Packet
|
||
header 4
|
||
pid 4
|
||
*/
|
||
if (!ch->GetDesc())
|
||
return;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+4;
|
||
pack.subheader = GUILD_SUBHEADER_GC_LOGOUT;
|
||
|
||
TEMP_BUFFER buf;
|
||
|
||
buf.write(&pack, sizeof(pack));
|
||
buf.write(&pid, 4);
|
||
|
||
ch->GetDesc()->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
|
||
void CGuild::LoadGuildMemberData(SQLMsg* pmsg)
|
||
{
|
||
if (pmsg->Get()->uiNumRows == 0)
|
||
return;
|
||
|
||
m_general_count = 0;
|
||
|
||
m_member.clear();
|
||
|
||
for (uint i = 0; i < pmsg->Get()->uiNumRows; ++i)
|
||
{
|
||
MYSQL_ROW row = mysql_fetch_row(pmsg->Get()->pSQLResult);
|
||
|
||
DWORD pid = strtoul(row[0], (char**) NULL, 10);
|
||
BYTE grade = (BYTE) strtoul(row[1], (char**) NULL, 10);
|
||
BYTE is_general = 0;
|
||
|
||
if (row[2] && *row[2] == '1')
|
||
is_general = 1;
|
||
|
||
DWORD offer = strtoul(row[3], (char**) NULL, 10);
|
||
BYTE level = (BYTE)strtoul(row[4], (char**) NULL, 10);
|
||
BYTE job = (BYTE)strtoul(row[5], (char**) NULL, 10);
|
||
char * name = row[6];
|
||
|
||
if (is_general)
|
||
m_general_count++;
|
||
|
||
m_member.insert(std::make_pair(pid, TGuildMember(pid, grade, is_general, job, level, offer, name)));
|
||
CGuildManager::instance().Link(pid, this);
|
||
}
|
||
}
|
||
|
||
void CGuild::LoadGuildGradeData(SQLMsg* pmsg)
|
||
{
|
||
/*
|
||
// 15<31><35> <20>ƴ<EFBFBD> <20><><EFBFBD>ɼ<EFBFBD> <20><><EFBFBD><EFBFBD>
|
||
if (pmsg->Get()->iNumRows != 15)
|
||
{
|
||
SPDLOG_ERROR("Query failed: getting guild grade data. GuildID({})", GetID());
|
||
return;
|
||
}
|
||
*/
|
||
for (uint i = 0; i < pmsg->Get()->uiNumRows; ++i)
|
||
{
|
||
MYSQL_ROW row = mysql_fetch_row(pmsg->Get()->pSQLResult);
|
||
BYTE grade = 0;
|
||
str_to_number(grade, row[0]);
|
||
char * name = row[1];
|
||
DWORD auth = strtoul(row[2], NULL, 10);
|
||
|
||
if (grade >= 1 && grade <= 15)
|
||
{
|
||
strlcpy(m_data.grade_array[grade-1].grade_name, name, sizeof(m_data.grade_array[grade-1].grade_name));
|
||
m_data.grade_array[grade-1].auth_flag = auth;
|
||
}
|
||
}
|
||
}
|
||
void CGuild::LoadGuildData(SQLMsg* pmsg)
|
||
{
|
||
if (pmsg->Get()->uiNumRows == 0)
|
||
{
|
||
SPDLOG_ERROR("Query failed: getting guild data {}", pmsg->stQuery.c_str());
|
||
return;
|
||
}
|
||
|
||
MYSQL_ROW row = mysql_fetch_row(pmsg->Get()->pSQLResult);
|
||
m_data.master_pid = strtoul(row[0], (char **)NULL, 10);
|
||
m_data.level = (BYTE)strtoul(row[1], (char **)NULL, 10);
|
||
m_data.exp = strtoul(row[2], (char **)NULL, 10);
|
||
strlcpy(m_data.name, row[3], sizeof(m_data.name));
|
||
|
||
m_data.skill_point = (BYTE) strtoul(row[4], (char **) NULL, 10);
|
||
if (row[5])
|
||
memcpy(m_data.abySkill, row[5], sizeof(BYTE) * GUILD_SKILL_COUNT);
|
||
else
|
||
memset(m_data.abySkill, 0, sizeof(BYTE) * GUILD_SKILL_COUNT);
|
||
|
||
m_data.power = std::max<int>(0, strtoul(row[6], (char **) NULL, 10));
|
||
|
||
str_to_number(m_data.ladder_point, row[7]);
|
||
|
||
if (m_data.ladder_point < 0)
|
||
m_data.ladder_point = 0;
|
||
|
||
str_to_number(m_data.win, row[8]);
|
||
str_to_number(m_data.draw, row[9]);
|
||
str_to_number(m_data.loss, row[10]);
|
||
str_to_number(m_data.gold, row[11]);
|
||
|
||
ComputeGuildPoints();
|
||
}
|
||
|
||
void CGuild::Load(DWORD guild_id)
|
||
{
|
||
Initialize();
|
||
|
||
m_data.guild_id = guild_id;
|
||
|
||
DBManager::instance().FuncQuery(std::bind1st(std::mem_fun(&CGuild::LoadGuildData), this),
|
||
"SELECT master, level, exp, name, skill_point, skill, sp, ladder_point, win, draw, loss, gold FROM guild%s WHERE id = %u", get_table_postfix(), m_data.guild_id);
|
||
|
||
SPDLOG_DEBUG("GUILD: loading guild id {:>12} {}", m_data.name, guild_id);
|
||
|
||
DBManager::instance().FuncQuery(std::bind1st(std::mem_fun(&CGuild::LoadGuildGradeData), this),
|
||
"SELECT grade, name, auth+0 FROM guild_grade%s WHERE guild_id = %u", get_table_postfix(), m_data.guild_id);
|
||
|
||
DBManager::instance().FuncQuery(std::bind1st(std::mem_fun(&CGuild::LoadGuildMemberData), this),
|
||
"SELECT pid, grade, is_general, offer, level, job, name FROM guild_member%s, player%s WHERE guild_id = %u and pid = id", get_table_postfix(), get_table_postfix(), guild_id);
|
||
}
|
||
|
||
void CGuild::SaveLevel()
|
||
{
|
||
DBManager::instance().Query("UPDATE guild%s SET level=%d, exp=%u, skill_point=%d WHERE id = %u", get_table_postfix(), m_data.level,m_data.exp, m_data.skill_point,m_data.guild_id);
|
||
}
|
||
|
||
void CGuild::SendDBSkillUpdate(int amount)
|
||
{
|
||
TPacketGuildSkillUpdate guild_skill;
|
||
guild_skill.guild_id = m_data.guild_id;
|
||
guild_skill.amount = amount;
|
||
guild_skill.skill_point = m_data.skill_point;
|
||
memcpy(guild_skill.skill_levels, m_data.abySkill, sizeof(BYTE) * GUILD_SKILL_COUNT);
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_SKILL_UPDATE, 0, &guild_skill, sizeof(guild_skill));
|
||
}
|
||
|
||
void CGuild::SaveSkill()
|
||
{
|
||
char text[GUILD_SKILL_COUNT * 2 + 1];
|
||
|
||
DBManager::instance().EscapeString(text, sizeof(text), (const char *) m_data.abySkill, sizeof(m_data.abySkill));
|
||
DBManager::instance().Query("UPDATE guild%s SET sp = %d, skill_point=%d, skill='%s' WHERE id = %u",
|
||
get_table_postfix(), m_data.power, m_data.skill_point, text, m_data.guild_id);
|
||
}
|
||
|
||
TGuildMember* CGuild::GetMember(DWORD pid)
|
||
{
|
||
TGuildMemberContainer::iterator it = m_member.find(pid);
|
||
if (it==m_member.end())
|
||
return NULL;
|
||
|
||
return &it->second;
|
||
}
|
||
|
||
DWORD CGuild::GetMemberPID(const std::string& strName)
|
||
{
|
||
for ( TGuildMemberContainer::iterator iter = m_member.begin();
|
||
iter != m_member.end(); iter++ )
|
||
{
|
||
if ( iter->second.name == strName ) return iter->first;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
void CGuild::__P2PUpdateGrade(SQLMsg* pmsg)
|
||
{
|
||
if (pmsg->Get()->uiNumRows)
|
||
{
|
||
MYSQL_ROW row = mysql_fetch_row(pmsg->Get()->pSQLResult);
|
||
|
||
int grade = 0;
|
||
const char* name = row[1];
|
||
int auth = 0;
|
||
|
||
str_to_number(grade, row[0]);
|
||
str_to_number(auth, row[2]);
|
||
|
||
if (grade <= 0)
|
||
return;
|
||
|
||
grade--;
|
||
|
||
// <20><><EFBFBD><EFBFBD> <20><>Ī<EFBFBD><C4AA> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD><D9B8>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ
|
||
if (0 != strcmp(m_data.grade_array[grade].grade_name, name))
|
||
{
|
||
strlcpy(m_data.grade_array[grade].grade_name, name, sizeof(m_data.grade_array[grade].grade_name));
|
||
|
||
TPacketGCGuild pack;
|
||
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack);
|
||
pack.subheader = GUILD_SUBHEADER_GC_GRADE_NAME;
|
||
|
||
TOneGradeNamePacket pack2;
|
||
|
||
pack.size += sizeof(pack2);
|
||
pack2.grade = grade + 1;
|
||
strlcpy(pack2.grade_name, name, sizeof(pack2.grade_name));
|
||
|
||
TEMP_BUFFER buf;
|
||
|
||
buf.write(&pack,sizeof(pack));
|
||
buf.write(&pack2,sizeof(pack2));
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it!=m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
|
||
if (d)
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
}
|
||
|
||
if (m_data.grade_array[grade].auth_flag != auth)
|
||
{
|
||
m_data.grade_array[grade].auth_flag = auth;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack);
|
||
pack.subheader = GUILD_SUBHEADER_GC_GRADE_AUTH;
|
||
|
||
TOneGradeAuthPacket pack2;
|
||
pack.size+=sizeof(pack2);
|
||
pack2.grade = grade+1;
|
||
pack2.auth = auth;
|
||
|
||
TEMP_BUFFER buf;
|
||
buf.write(&pack,sizeof(pack));
|
||
buf.write(&pack2,sizeof(pack2));
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it!=m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
if (d)
|
||
{
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void CGuild::P2PChangeGrade(BYTE grade)
|
||
{
|
||
DBManager::instance().FuncQuery(std::bind1st(std::mem_fun(&CGuild::__P2PUpdateGrade),this),
|
||
"SELECT grade, name, auth+0 FROM guild_grade%s WHERE guild_id = %u and grade = %d", get_table_postfix(), m_data.guild_id, grade);
|
||
}
|
||
|
||
namespace
|
||
{
|
||
struct FSendChangeGrade
|
||
{
|
||
BYTE grade;
|
||
TPacketGuild p;
|
||
|
||
FSendChangeGrade(DWORD guild_id, BYTE grade) : grade(grade)
|
||
{
|
||
p.dwGuild = guild_id;
|
||
p.dwInfo = grade;
|
||
}
|
||
|
||
void operator()()
|
||
{
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_CHANGE_GRADE, 0, &p, sizeof(p));
|
||
}
|
||
};
|
||
}
|
||
|
||
void CGuild::ChangeGradeName(BYTE grade, const char* grade_name)
|
||
{
|
||
if (grade == 1)
|
||
return;
|
||
|
||
if (grade < 1 || grade > 15)
|
||
{
|
||
SPDLOG_ERROR("Wrong guild grade value {}", grade);
|
||
return;
|
||
}
|
||
|
||
if (strlen(grade_name) > GUILD_NAME_MAX_LEN)
|
||
return;
|
||
|
||
if (!*grade_name)
|
||
return;
|
||
|
||
char text[GUILD_NAME_MAX_LEN * 2 + 1];
|
||
|
||
DBManager::instance().EscapeString(text, sizeof(text), grade_name, strlen(grade_name));
|
||
DBManager::instance().FuncAfterQuery(FSendChangeGrade(GetID(), grade), "UPDATE guild_grade%s SET name = '%s' where guild_id = %u and grade = %d", get_table_postfix(), text, m_data.guild_id, grade);
|
||
|
||
grade--;
|
||
strlcpy(m_data.grade_array[grade].grade_name, grade_name, sizeof(m_data.grade_array[grade].grade_name));
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack);
|
||
pack.subheader = GUILD_SUBHEADER_GC_GRADE_NAME;
|
||
|
||
TOneGradeNamePacket pack2;
|
||
pack.size+=sizeof(pack2);
|
||
pack2.grade = grade+1;
|
||
strlcpy(pack2.grade_name,grade_name, sizeof(pack2.grade_name));
|
||
|
||
TEMP_BUFFER buf;
|
||
buf.write(&pack,sizeof(pack));
|
||
buf.write(&pack2,sizeof(pack2));
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it!=m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
|
||
if (d)
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
}
|
||
|
||
void CGuild::ChangeGradeAuth(BYTE grade, BYTE auth)
|
||
{
|
||
if (grade == 1)
|
||
return;
|
||
|
||
if (grade < 1 || grade > 15)
|
||
{
|
||
SPDLOG_ERROR("Wrong guild grade value {}", grade);
|
||
return;
|
||
}
|
||
|
||
DBManager::instance().FuncAfterQuery(FSendChangeGrade(GetID(),grade), "UPDATE guild_grade%s SET auth = %d where guild_id = %u and grade = %d", get_table_postfix(), auth, m_data.guild_id, grade);
|
||
|
||
grade--;
|
||
|
||
m_data.grade_array[grade].auth_flag=auth;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack);
|
||
pack.subheader = GUILD_SUBHEADER_GC_GRADE_AUTH;
|
||
|
||
TOneGradeAuthPacket pack2;
|
||
pack.size += sizeof(pack2);
|
||
pack2.grade = grade + 1;
|
||
pack2.auth = auth;
|
||
|
||
TEMP_BUFFER buf;
|
||
buf.write(&pack, sizeof(pack));
|
||
buf.write(&pack2, sizeof(pack2));
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
|
||
if (d)
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
}
|
||
|
||
void CGuild::SendGuildInfoPacket(LPCHARACTER ch)
|
||
{
|
||
LPDESC d = ch->GetDesc();
|
||
|
||
if (!d)
|
||
return;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(TPacketGCGuild) + sizeof(TPacketGCGuildInfo);
|
||
pack.subheader = GUILD_SUBHEADER_GC_INFO;
|
||
|
||
TPacketGCGuildInfo pack_sub;
|
||
|
||
memset(&pack_sub, 0, sizeof(TPacketGCGuildInfo));
|
||
pack_sub.member_count = GetMemberCount();
|
||
pack_sub.max_member_count = GetMaxMemberCount();
|
||
pack_sub.guild_id = m_data.guild_id;
|
||
pack_sub.master_pid = m_data.master_pid;
|
||
pack_sub.exp = m_data.exp;
|
||
pack_sub.level = m_data.level;
|
||
strlcpy(pack_sub.name, m_data.name, sizeof(pack_sub.name));
|
||
pack_sub.gold = m_data.gold;
|
||
pack_sub.has_land = HasLand();
|
||
|
||
SPDLOG_DEBUG("GMC guild_name {}", m_data.name);
|
||
SPDLOG_DEBUG("GMC master {}", m_data.master_pid);
|
||
|
||
d->RawPacket(&pack, sizeof(TPacketGCGuild));
|
||
d->Packet(&pack_sub, sizeof(TPacketGCGuildInfo));
|
||
}
|
||
|
||
bool CGuild::OfferExp(LPCHARACTER ch, int amount)
|
||
{
|
||
TGuildMemberContainer::iterator cit = m_member.find(ch->GetPlayerID());
|
||
|
||
if (cit == m_member.end())
|
||
return false;
|
||
|
||
if (m_data.exp+amount < m_data.exp)
|
||
return false;
|
||
|
||
if (amount < 0)
|
||
return false;
|
||
|
||
if (ch->GetExp() < (DWORD) amount)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC1\xA6\xB0\xF8\xC7\xCF\xB0\xED\xC0\xDA \xC7\xCF\xB4\xC2 \xB0\xE6\xC7\xE8\xC4\xA1\xB0\xA1 \xB3\xB2\xC0\xBA \xB0\xE6\xC7\xE8\xC4\xA1\xBA\xB8\xB4\xD9 \xB8\xB9\xBD\xC0\xB4\xCF\xB4\xD9."));
|
||
return false;
|
||
}
|
||
|
||
if (ch->GetExp() - (DWORD) amount > ch->GetExp())
|
||
{
|
||
SPDLOG_ERROR("Wrong guild offer amount {} by {}[{}]", amount, ch->GetName(), ch->GetPlayerID());
|
||
return false;
|
||
}
|
||
|
||
ch->PointChange(POINT_EXP, -amount);
|
||
|
||
TPacketGuildExpUpdate guild_exp;
|
||
guild_exp.guild_id = GetID();
|
||
guild_exp.amount = amount / 100;
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_EXP_UPDATE, 0, &guild_exp, sizeof(guild_exp));
|
||
GuildPointChange(POINT_EXP, amount / 100, true);
|
||
|
||
cit->second.offer_exp += amount / 100;
|
||
cit->second._dummy = 0;
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
if (d)
|
||
{
|
||
pack.subheader = GUILD_SUBHEADER_GC_LIST;
|
||
pack.size = sizeof(pack) + 13;
|
||
d->RawPacket(&pack, sizeof(pack));
|
||
d->Packet(&(cit->second), sizeof(DWORD) * 3 + 1);
|
||
}
|
||
}
|
||
|
||
SaveMember(ch->GetPlayerID());
|
||
|
||
TPacketGuildChangeMemberData gd_guild;
|
||
|
||
gd_guild.guild_id = GetID();
|
||
gd_guild.pid = ch->GetPlayerID();
|
||
gd_guild.offer = cit->second.offer_exp;
|
||
gd_guild.level = ch->GetLevel();
|
||
gd_guild.grade = cit->second.grade;
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_CHANGE_MEMBER_DATA, 0, &gd_guild, sizeof(gd_guild));
|
||
return true;
|
||
}
|
||
|
||
void CGuild::Disband()
|
||
{
|
||
SPDLOG_DEBUG("GUILD: Disband {}:{}", GetName(), GetID());
|
||
|
||
//building::CLand* pLand = building::CManager::instance().FindLandByGuild(GetID());
|
||
//if (pLand)
|
||
//pLand->SetOwner(0);
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPCHARACTER ch = *it;
|
||
ch->SetGuild(NULL);
|
||
SendOnlineRemoveOnePacket(ch->GetPlayerID());
|
||
ch->SetQuestFlag("guild_manage.new_withdraw_time", get_global_time());
|
||
}
|
||
|
||
for (TGuildMemberContainer::iterator it = m_member.begin(); it != m_member.end(); ++it)
|
||
{
|
||
CGuildManager::instance().Unlink(it->first);
|
||
}
|
||
|
||
}
|
||
|
||
void CGuild::RequestDisband(DWORD pid)
|
||
{
|
||
if (m_data.master_pid != pid)
|
||
return;
|
||
|
||
TPacketGuild gd_guild;
|
||
gd_guild.dwGuild = GetID();
|
||
gd_guild.dwInfo = 0;
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_DISBAND, 0, &gd_guild, sizeof(TPacketGuild));
|
||
|
||
// LAND_CLEAR
|
||
building::CManager::instance().ClearLandByGuildID(GetID());
|
||
// END_LAND_CLEAR
|
||
}
|
||
|
||
void CGuild::AddComment(LPCHARACTER ch, const std::string& str)
|
||
{
|
||
if (str.length() > GUILD_COMMENT_MAX_LEN)
|
||
return;
|
||
|
||
char text[GUILD_COMMENT_MAX_LEN * 2 + 1];
|
||
DBManager::instance().EscapeString(text, sizeof(text), str.c_str(), str.length());
|
||
|
||
DBManager::instance().FuncAfterQuery(void_bind(std::bind1st(std::mem_fun(&CGuild::RefreshCommentForce),this),ch->GetPlayerID()),
|
||
"INSERT INTO guild_comment%s(guild_id, name, notice, content, time) VALUES(%u, '%s', %d, '%s', NOW())",
|
||
get_table_postfix(), m_data.guild_id, ch->GetName(), (str[0] == '!') ? 1 : 0, text);
|
||
}
|
||
|
||
void CGuild::DeleteComment(LPCHARACTER ch, DWORD comment_id)
|
||
{
|
||
SQLMsg * pmsg;
|
||
|
||
if (GetMember(ch->GetPlayerID())->grade == GUILD_LEADER_GRADE)
|
||
pmsg = DBManager::instance().DirectQuery("DELETE FROM guild_comment%s WHERE id = %u AND guild_id = %u",get_table_postfix(), comment_id, m_data.guild_id);
|
||
else
|
||
pmsg = DBManager::instance().DirectQuery("DELETE FROM guild_comment%s WHERE id = %u AND guild_id = %u AND name = '%s'",get_table_postfix(), comment_id, m_data.guild_id, ch->GetName());
|
||
|
||
if (pmsg->Get()->uiAffectedRows == 0 || pmsg->Get()->uiAffectedRows == (uint32_t)-1)
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBB\xE8\xC1\xA6\xC7\xD2 \xBC\xF6 \xBE\xF8\xB4\xC2 \xB1\xDB\xC0\xD4\xB4\xCF\xB4\xD9."));
|
||
else
|
||
RefreshCommentForce(ch->GetPlayerID());
|
||
|
||
M2_DELETE(pmsg);
|
||
}
|
||
|
||
void CGuild::RefreshComment(LPCHARACTER ch)
|
||
{
|
||
RefreshCommentForce(ch->GetPlayerID());
|
||
}
|
||
|
||
void CGuild::RefreshCommentForce(DWORD player_id)
|
||
{
|
||
LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(player_id);
|
||
if (ch == NULL) {
|
||
return;
|
||
}
|
||
|
||
std::unique_ptr<SQLMsg> pmsg (DBManager::instance().DirectQuery("SELECT id, name, content FROM guild_comment%s WHERE guild_id = %u ORDER BY notice DESC, id DESC LIMIT %d", get_table_postfix(), m_data.guild_id, GUILD_COMMENT_MAX_COUNT));
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+1;
|
||
pack.subheader = GUILD_SUBHEADER_GC_COMMENTS;
|
||
|
||
BYTE count = pmsg->Get()->uiNumRows;
|
||
|
||
LPDESC d = ch->GetDesc();
|
||
|
||
if (!d)
|
||
return;
|
||
|
||
pack.size += (sizeof(DWORD)+CHARACTER_NAME_MAX_LEN+1+GUILD_COMMENT_MAX_LEN+1)*(WORD)count;
|
||
d->RawPacket(&pack, sizeof(pack));
|
||
d->RawPacket(&count, 1);
|
||
char szName[CHARACTER_NAME_MAX_LEN + 1];
|
||
char szContent[GUILD_COMMENT_MAX_LEN + 1];
|
||
memset(szName, 0, sizeof(szName));
|
||
memset(szContent, 0, sizeof(szContent));
|
||
|
||
for (uint i = 0; i < pmsg->Get()->uiNumRows; i++)
|
||
{
|
||
MYSQL_ROW row = mysql_fetch_row(pmsg->Get()->pSQLResult);
|
||
DWORD id = strtoul(row[0], NULL, 10);
|
||
|
||
strlcpy(szName, row[1], sizeof(szName));
|
||
strlcpy(szContent, row[2], sizeof(szContent));
|
||
|
||
d->RawPacket(&id, sizeof(id));
|
||
d->RawPacket(szName, sizeof(szName));
|
||
|
||
if (i == pmsg->Get()->uiNumRows - 1)
|
||
d->Packet(szContent, sizeof(szContent)); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
else
|
||
d->RawPacket(szContent, sizeof(szContent));
|
||
}
|
||
}
|
||
|
||
bool CGuild::ChangeMemberGeneral(DWORD pid, BYTE is_general)
|
||
{
|
||
if (is_general && GetGeneralCount() >= GetMaxGeneralCount())
|
||
return false;
|
||
|
||
TGuildMemberContainer::iterator it = m_member.find(pid);
|
||
if (it == m_member.end())
|
||
{
|
||
return true;
|
||
}
|
||
|
||
is_general = is_general?1:0;
|
||
|
||
if (it->second.is_general == is_general)
|
||
return true;
|
||
|
||
if (is_general)
|
||
++m_general_count;
|
||
else
|
||
--m_general_count;
|
||
|
||
it->second.is_general = is_general;
|
||
|
||
TGuildMemberOnlineContainer::iterator itOnline = m_memberOnline.begin();
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+5;
|
||
pack.subheader = GUILD_SUBHEADER_GC_CHANGE_MEMBER_GENERAL;
|
||
|
||
while (itOnline != m_memberOnline.end())
|
||
{
|
||
LPDESC d = (*(itOnline++))->GetDesc();
|
||
|
||
if (!d)
|
||
continue;
|
||
|
||
d->RawPacket(&pack, sizeof(pack));
|
||
d->RawPacket(&pid, sizeof(pid));
|
||
d->Packet(&is_general, sizeof(is_general));
|
||
}
|
||
|
||
SaveMember(pid);
|
||
return true;
|
||
}
|
||
|
||
void CGuild::ChangeMemberGrade(DWORD pid, BYTE grade)
|
||
{
|
||
if (grade == 1)
|
||
return;
|
||
|
||
TGuildMemberContainer::iterator it = m_member.find(pid);
|
||
|
||
if (it == m_member.end())
|
||
return;
|
||
|
||
it->second.grade = grade;
|
||
|
||
TGuildMemberOnlineContainer::iterator itOnline = m_memberOnline.begin();
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+5;
|
||
pack.subheader = GUILD_SUBHEADER_GC_CHANGE_MEMBER_GRADE;
|
||
|
||
while (itOnline != m_memberOnline.end())
|
||
{
|
||
LPDESC d = (*(itOnline++))->GetDesc();
|
||
|
||
if (!d)
|
||
continue;
|
||
|
||
d->RawPacket(&pack, sizeof(pack));
|
||
d->RawPacket(&pid, sizeof(pid));
|
||
d->Packet(&grade, sizeof(grade));
|
||
}
|
||
|
||
SaveMember(pid);
|
||
|
||
TPacketGuildChangeMemberData gd_guild;
|
||
|
||
gd_guild.guild_id = GetID();
|
||
gd_guild.pid = pid;
|
||
gd_guild.offer = it->second.offer_exp;
|
||
gd_guild.level = it->second.level;
|
||
gd_guild.grade = grade;
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_CHANGE_MEMBER_DATA, 0, &gd_guild, sizeof(gd_guild));
|
||
}
|
||
|
||
void CGuild::SkillLevelUp(DWORD dwVnum)
|
||
{
|
||
DWORD dwRealVnum = dwVnum - GUILD_SKILL_START;
|
||
|
||
if (dwRealVnum >= GUILD_SKILL_COUNT)
|
||
return;
|
||
|
||
CSkillProto* pkSk = CSkillManager::instance().Get(dwVnum);
|
||
|
||
if (!pkSk)
|
||
{
|
||
SPDLOG_ERROR("There is no such guild skill by number {}", dwVnum);
|
||
return;
|
||
}
|
||
|
||
if (m_data.abySkill[dwRealVnum] >= pkSk->bMaxLevel)
|
||
return;
|
||
|
||
if (m_data.skill_point <= 0)
|
||
return;
|
||
m_data.skill_point --;
|
||
|
||
m_data.abySkill[dwRealVnum] ++;
|
||
|
||
ComputeGuildPoints();
|
||
SaveSkill();
|
||
SendDBSkillUpdate();
|
||
|
||
/*switch (dwVnum)
|
||
{
|
||
case GUILD_SKILL_GAHO:
|
||
{
|
||
TGuildMemberOnlineContainer::iterator it;
|
||
|
||
for (it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
(*it)->PointChange(POINT_DEF_GRADE, 1);
|
||
}
|
||
break;
|
||
case GUILD_SKILL_HIM:
|
||
{
|
||
TGuildMemberOnlineContainer::iterator it;
|
||
|
||
for (it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
(*it)->PointChange(POINT_ATT_GRADE, 1);
|
||
}
|
||
break;
|
||
}*/
|
||
|
||
for_each(m_memberOnline.begin(), m_memberOnline.end(), std::bind1st(std::mem_fun_ref(&CGuild::SendSkillInfoPacket),*this));
|
||
|
||
SPDLOG_DEBUG("Guild SkillUp: {} {} level {} type {}", GetName(), pkSk->dwVnum, m_data.abySkill[dwRealVnum], pkSk->dwType);
|
||
}
|
||
|
||
void CGuild::UseSkill(DWORD dwVnum, LPCHARACTER ch, DWORD pid)
|
||
{
|
||
LPCHARACTER victim = NULL;
|
||
|
||
if (!GetMember(ch->GetPlayerID()) || !HasGradeAuth(GetMember(ch->GetPlayerID())->grade, GUILD_AUTH_USE_SKILL))
|
||
return;
|
||
|
||
SPDLOG_DEBUG("GUILD_USE_SKILL : cname({}), skill({})", ch ? ch->GetName() : "", dwVnum);
|
||
|
||
DWORD dwRealVnum = dwVnum - GUILD_SKILL_START;
|
||
|
||
if (!ch->CanMove())
|
||
return;
|
||
|
||
if (dwRealVnum >= GUILD_SKILL_COUNT)
|
||
return;
|
||
|
||
CSkillProto* pkSk = CSkillManager::instance().Get(dwVnum);
|
||
|
||
if (!pkSk)
|
||
{
|
||
SPDLOG_ERROR("There is no such guild skill by number {}", dwVnum);
|
||
return;
|
||
}
|
||
|
||
if (m_data.abySkill[dwRealVnum] == 0)
|
||
return;
|
||
|
||
if ((pkSk->dwFlag & SKILL_FLAG_SELFONLY))
|
||
{
|
||
// <20>̹<EFBFBD> <20>ɷ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
|
||
if (ch->FindAffect(pkSk->dwVnum))
|
||
return;
|
||
|
||
victim = ch;
|
||
}
|
||
|
||
if (ch->IsAffectFlag(AFF_REVIVE_INVISIBLE))
|
||
ch->RemoveAffect(AFFECT_REVIVE_INVISIBLE);
|
||
|
||
if (ch->IsAffectFlag(AFF_EUNHYUNG))
|
||
ch->RemoveAffect(SKILL_EUNHYUNG);
|
||
|
||
double k =1.0*m_data.abySkill[dwRealVnum]/pkSk->bMaxLevel;
|
||
pkSk->kSPCostPoly.SetVar("k", k);
|
||
int iNeededSP = (int) pkSk->kSPCostPoly.Eval();
|
||
|
||
if (GetSP() < iNeededSP)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBF\xEB\xBD\xC5\xB7\xC2\xC0\xCC \xBA\xCE\xC1\xB7\xC7\xD5\xB4\xCF\xB4\xD9. (%d, %d)"), GetSP(), iNeededSP);
|
||
return;
|
||
}
|
||
|
||
pkSk->kCooldownPoly.SetVar("k", k);
|
||
int iCooltime = (int) pkSk->kCooldownPoly.Eval();
|
||
|
||
if (!abSkillUsable[dwRealVnum])
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC4\xF0\xC5\xB8\xC0\xD3\xC0\xCC \xB3\xA1\xB3\xAA\xC1\xF6 \xBE\xCA\xBE\xC6 \xB1\xE6\xB5\xE5 \xBD\xBA\xC5\xB3\xC0\xBB \xBB\xE7\xBF\xEB\xC7\xD2 \xBC\xF6 \xBE\xF8\xBD\xC0\xB4\xCF\xB4\xD9."));
|
||
return;
|
||
}
|
||
|
||
{
|
||
TPacketGuildUseSkill p;
|
||
p.dwGuild = GetID();
|
||
p.dwSkillVnum = pkSk->dwVnum;
|
||
p.dwCooltime = iCooltime;
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_USE_SKILL, 0, &p, sizeof(p));
|
||
}
|
||
abSkillUsable[dwRealVnum] = false;
|
||
//abSkillUsed[dwRealVnum] = true;
|
||
//adwSkillNextUseTime[dwRealVnum] = get_dword_time() + iCooltime * 1000;
|
||
|
||
//PointChange(POINT_SP, -iNeededSP);
|
||
//GuildPointChange(POINT_SP, -iNeededSP);
|
||
|
||
if (test_server)
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> %d \xBD\xBA\xC5\xB3\xC0\xBB \xBB\xE7\xBF\xEB\xC7\xD4 (%d, %d) to %u"), dwVnum, GetSP(), iNeededSP, pid);
|
||
|
||
switch (dwVnum)
|
||
{
|
||
case GUILD_SKILL_TELEPORT:
|
||
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>õ<EFBFBD>.
|
||
SendDBSkillUpdate(-iNeededSP);
|
||
if ((victim = (CHARACTER_MANAGER::instance().FindByPID(pid))))
|
||
ch->WarpSet(victim->GetX(), victim->GetY());
|
||
else
|
||
{
|
||
if (m_memberP2POnline.find(pid) != m_memberP2POnline.end())
|
||
{
|
||
// <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1>ε<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> -> <20><EFBFBD><DEBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ǥ<EFBFBD><C7A5> <20>ƿ<DEBE><C6BF><EFBFBD>
|
||
// 1. A.pid, B.pid <20><> <20>Ѹ<EFBFBD>
|
||
// 2. B.pid<69><64> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ѹ<EFBFBD><D1B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> A.pid, <20><>ǥ <20><> <20><><EFBFBD><EFBFBD>
|
||
// 3. <20><><EFBFBD><EFBFBD>
|
||
CCI * pcci = P2P_MANAGER::instance().FindByPID(pid);
|
||
|
||
if (pcci->bChannel != g_bChannel)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBB\xF3\xB4\xEB\xB0\xA1 %d \xC3\xA4\xB3\xCE\xBF\xA1 \xC0\xD6\xBD\xC0\xB4\xCF\xB4\xD9. (\xC7\xF6\xC0\xE7 \xC3\xA4\xB3\xCE %d)"), pcci->bChannel, g_bChannel);
|
||
}
|
||
else
|
||
{
|
||
TPacketGGFindPosition p;
|
||
p.header = HEADER_GG_FIND_POSITION;
|
||
p.dwFromPID = ch->GetPlayerID();
|
||
p.dwTargetPID = pid;
|
||
pcci->pkDesc->Packet(&p, sizeof(TPacketGGFindPosition));
|
||
if (test_server) ch->ChatPacket(CHAT_TYPE_PARTY, "sent find position packet for guild teleport");
|
||
}
|
||
}
|
||
else
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBB\xF3\xB4\xEB\xB0\xA1 \xBF\xC2\xB6\xF3\xC0\xCE \xBB\xF3\xC5\xC2\xB0\xA1 \xBE\xC6\xB4\xD5\xB4\xCF\xB4\xD9."));
|
||
}
|
||
break;
|
||
|
||
/*case GUILD_SKILL_ACCEL:
|
||
ch->RemoveAffect(dwVnum);
|
||
ch->AddAffect(dwVnum, POINT_MOV_SPEED, m_data.abySkill[dwRealVnum]*3, pkSk->dwAffectFlag, (int)pkSk->kDurationPoly.Eval(), 0, false);
|
||
ch->AddAffect(dwVnum, POINT_ATT_SPEED, m_data.abySkill[dwRealVnum]*3, pkSk->dwAffectFlag, (int)pkSk->kDurationPoly.Eval(), 0, false);
|
||
break;*/
|
||
|
||
default:
|
||
{
|
||
/*if (ch->GetPlayerID() != GetMasterPID())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xB1\xE6\xB5\xE5\xC0\xE5\xB8\xB8 \xB1\xE6\xB5\xE5 \xBD\xBA\xC5\xB3\xC0\xBB \xBB\xE7\xBF\xEB\xC7\xD2 \xBC\xF6 \xC0\xD6\xBD\xC0\xB4\xCF\xB4\xD9."));
|
||
return;
|
||
}*/
|
||
|
||
if (!UnderAnyWar())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xB1\xE6\xB5\xE5 \xBD\xBA\xC5\xB3\xC0\xBA \xB1\xE6\xB5\xE5\xC0\xFC \xC1\xDF\xBF\xA1\xB8\xB8 \xBB\xE7\xBF\xEB\xC7\xD2 \xBC\xF6 \xC0\xD6\xBD\xC0\xB4\xCF\xB4\xD9."));
|
||
return;
|
||
}
|
||
|
||
SendDBSkillUpdate(-iNeededSP);
|
||
|
||
for (itertype(m_memberOnline) it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPCHARACTER victim = *it;
|
||
victim->RemoveAffect(dwVnum);
|
||
ch->ComputeSkill(dwVnum, victim, m_data.abySkill[dwRealVnum]);
|
||
}
|
||
}
|
||
break;
|
||
/*if (!victim)
|
||
return;
|
||
|
||
ch->ComputeSkill(dwVnum, victim, m_data.abySkill[dwRealVnum]);*/
|
||
}
|
||
}
|
||
|
||
void CGuild::SendSkillInfoPacket(LPCHARACTER ch) const
|
||
{
|
||
LPDESC d = ch->GetDesc();
|
||
|
||
if (!d)
|
||
return;
|
||
|
||
TPacketGCGuild pack;
|
||
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack) + 6 + GUILD_SKILL_COUNT;
|
||
pack.subheader = GUILD_SUBHEADER_GC_SKILL_INFO;
|
||
|
||
d->RawPacket(&pack, sizeof(pack));
|
||
d->RawPacket(&m_data.skill_point, 1);
|
||
d->RawPacket(&m_data.abySkill, GUILD_SKILL_COUNT);
|
||
d->RawPacket(&m_data.power, 2);
|
||
d->Packet(&m_data.max_power, 2);
|
||
}
|
||
|
||
void CGuild::ComputeGuildPoints()
|
||
{
|
||
m_data.max_power = GUILD_BASE_POWER + (m_data.level-1) * GUILD_POWER_PER_LEVEL;
|
||
|
||
m_data.power = std::clamp(m_data.power, 0, m_data.max_power);
|
||
}
|
||
|
||
int CGuild::GetSkillLevel(DWORD vnum)
|
||
{
|
||
DWORD dwRealVnum = vnum - GUILD_SKILL_START;
|
||
|
||
if (dwRealVnum >= GUILD_SKILL_COUNT)
|
||
return 0;
|
||
|
||
return m_data.abySkill[dwRealVnum];
|
||
}
|
||
|
||
/*void CGuild::GuildUpdateAffect(LPCHARACTER ch)
|
||
{
|
||
if (GetSkillLevel(GUILD_SKILL_GAHO))
|
||
ch->PointChange(POINT_DEF_GRADE, GetSkillLevel(GUILD_SKILL_GAHO));
|
||
|
||
if (GetSkillLevel(GUILD_SKILL_HIM))
|
||
ch->PointChange(POINT_ATT_GRADE, GetSkillLevel(GUILD_SKILL_HIM));
|
||
}*/
|
||
|
||
/*void CGuild::GuildRemoveAffect(LPCHARACTER ch)
|
||
{
|
||
if (GetSkillLevel(GUILD_SKILL_GAHO))
|
||
ch->PointChange(POINT_DEF_GRADE, -(int) GetSkillLevel(GUILD_SKILL_GAHO));
|
||
|
||
if (GetSkillLevel(GUILD_SKILL_HIM))
|
||
ch->PointChange(POINT_ATT_GRADE, -(int) GetSkillLevel(GUILD_SKILL_HIM));
|
||
}*/
|
||
|
||
void CGuild::UpdateSkill(BYTE skill_point, BYTE* skill_levels)
|
||
{
|
||
//int iDefMoreBonus = 0;
|
||
//int iAttMoreBonus = 0;
|
||
|
||
m_data.skill_point = skill_point;
|
||
/*if (skill_levels[GUILD_SKILL_GAHO - GUILD_SKILL_START]!=GetSkillLevel(GUILD_SKILL_GAHO))
|
||
{
|
||
iDefMoreBonus = skill_levels[GUILD_SKILL_GAHO - GUILD_SKILL_START]-GetSkillLevel(GUILD_SKILL_GAHO);
|
||
}
|
||
if (skill_levels[GUILD_SKILL_HIM - GUILD_SKILL_START]!=GetSkillLevel(GUILD_SKILL_HIM))
|
||
{
|
||
iAttMoreBonus = skill_levels[GUILD_SKILL_HIM - GUILD_SKILL_START]-GetSkillLevel(GUILD_SKILL_HIM);
|
||
}
|
||
|
||
if (iDefMoreBonus || iAttMoreBonus)
|
||
{
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
(*it)->PointChange(POINT_ATT_GRADE, iAttMoreBonus);
|
||
(*it)->PointChange(POINT_DEF_GRADE, iDefMoreBonus);
|
||
}
|
||
}*/
|
||
|
||
memcpy(m_data.abySkill, skill_levels, sizeof(BYTE) * GUILD_SKILL_COUNT);
|
||
ComputeGuildPoints();
|
||
}
|
||
|
||
static DWORD __guild_levelup_exp(int level)
|
||
{
|
||
if (LC_IsYMIR())
|
||
{
|
||
return guild_exp_table[level];
|
||
}
|
||
else
|
||
{
|
||
return guild_exp_table2[level];
|
||
}
|
||
}
|
||
|
||
void CGuild::GuildPointChange(BYTE type, int amount, bool save)
|
||
{
|
||
switch (type)
|
||
{
|
||
case POINT_SP:
|
||
m_data.power += amount;
|
||
|
||
m_data.power = std::clamp(m_data.power, 0, m_data.max_power);
|
||
|
||
if (save)
|
||
{
|
||
SaveSkill();
|
||
}
|
||
|
||
for_each(m_memberOnline.begin(), m_memberOnline.end(), std::bind1st(std::mem_fun_ref(&CGuild::SendSkillInfoPacket),*this));
|
||
break;
|
||
|
||
case POINT_EXP:
|
||
if (amount < 0 && m_data.exp < (DWORD) - amount)
|
||
{
|
||
m_data.exp = 0;
|
||
}
|
||
else
|
||
{
|
||
m_data.exp += amount;
|
||
|
||
while (m_data.exp >= __guild_levelup_exp(m_data.level))
|
||
{
|
||
|
||
if (m_data.level < GUILD_MAX_LEVEL)
|
||
{
|
||
m_data.exp -= __guild_levelup_exp(m_data.level);
|
||
++m_data.level;
|
||
++m_data.skill_point;
|
||
|
||
if (m_data.level > GUILD_MAX_LEVEL)
|
||
m_data.level = GUILD_MAX_LEVEL;
|
||
|
||
ComputeGuildPoints();
|
||
GuildPointChange(POINT_SP, m_data.max_power-m_data.power);
|
||
|
||
if (save)
|
||
ChangeLadderPoint(GUILD_LADDER_POINT_PER_LEVEL);
|
||
|
||
// NOTIFY_GUILD_EXP_CHANGE
|
||
for_each(m_memberOnline.begin(), m_memberOnline.end(), std::bind1st(std::mem_fun(&CGuild::SendGuildInfoPacket), this));
|
||
// END_OF_NOTIFY_GUILD_EXP_CHANGE
|
||
}
|
||
|
||
if (m_data.level == GUILD_MAX_LEVEL)
|
||
{
|
||
m_data.exp = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
pack.size = sizeof(pack)+5;
|
||
pack.subheader = GUILD_SUBHEADER_GC_CHANGE_EXP;
|
||
|
||
TEMP_BUFFER buf;
|
||
buf.write(&pack,sizeof(pack));
|
||
buf.write(&m_data.level,1);
|
||
buf.write(&m_data.exp,4);
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
|
||
if (d)
|
||
d->Packet(buf.read_peek(), buf.size());
|
||
}
|
||
|
||
if (save)
|
||
SaveLevel();
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
void CGuild::SkillRecharge()
|
||
{
|
||
//GuildPointChange(POINT_SP, m_data.max_power / 2);
|
||
//GuildPointChange(POINT_SP, 10);
|
||
}
|
||
|
||
void CGuild::SaveMember(DWORD pid)
|
||
{
|
||
TGuildMemberContainer::iterator it = m_member.find(pid);
|
||
|
||
if (it == m_member.end())
|
||
return;
|
||
|
||
DBManager::instance().Query(
|
||
"UPDATE guild_member%s SET grade = %d, offer = %u, is_general = %d WHERE pid = %u and guild_id = %u",
|
||
get_table_postfix(), it->second.grade, it->second.offer_exp, it->second.is_general, pid, m_data.guild_id);
|
||
}
|
||
|
||
void CGuild::LevelChange(DWORD pid, BYTE level)
|
||
{
|
||
TGuildMemberContainer::iterator cit = m_member.find(pid);
|
||
|
||
if (cit == m_member.end())
|
||
return;
|
||
|
||
cit->second.level = level;
|
||
|
||
TPacketGuildChangeMemberData gd_guild;
|
||
|
||
gd_guild.guild_id = GetID();
|
||
gd_guild.pid = pid;
|
||
gd_guild.offer = cit->second.offer_exp;
|
||
gd_guild.grade = cit->second.grade;
|
||
gd_guild.level = level;
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_CHANGE_MEMBER_DATA, 0, &gd_guild, sizeof(gd_guild));
|
||
|
||
TPacketGCGuild pack;
|
||
pack.header = HEADER_GC_GUILD;
|
||
cit->second._dummy = 0;
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
|
||
if (d)
|
||
{
|
||
pack.subheader = GUILD_SUBHEADER_GC_LIST;
|
||
pack.size = sizeof(pack) + 13;
|
||
d->RawPacket(&pack, sizeof(pack));
|
||
d->Packet(&(cit->second), sizeof(DWORD) * 3 + 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
void CGuild::ChangeMemberData(DWORD pid, DWORD offer, BYTE level, BYTE grade)
|
||
{
|
||
TGuildMemberContainer::iterator cit = m_member.find(pid);
|
||
|
||
if (cit == m_member.end())
|
||
return;
|
||
|
||
cit->second.offer_exp = offer;
|
||
cit->second.level = level;
|
||
cit->second.grade = grade;
|
||
cit->second._dummy = 0;
|
||
|
||
TPacketGCGuild pack;
|
||
memset(&pack, 0, sizeof(pack));
|
||
pack.header = HEADER_GC_GUILD;
|
||
|
||
for (TGuildMemberOnlineContainer::iterator it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
if (d)
|
||
{
|
||
pack.subheader = GUILD_SUBHEADER_GC_LIST;
|
||
pack.size = sizeof(pack) + 13;
|
||
d->RawPacket(&pack, sizeof(pack));
|
||
d->Packet(&(cit->second), sizeof(DWORD) * 3 + 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace
|
||
{
|
||
struct FGuildChat
|
||
{
|
||
const char* c_pszText;
|
||
|
||
FGuildChat(const char* c_pszText)
|
||
: c_pszText(c_pszText)
|
||
{}
|
||
|
||
void operator()(LPCHARACTER ch)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_GUILD, "%s", c_pszText);
|
||
}
|
||
};
|
||
}
|
||
|
||
void CGuild::P2PChat(const char* c_pszText)
|
||
{
|
||
std::for_each(m_memberOnline.begin(), m_memberOnline.end(), FGuildChat(c_pszText));
|
||
}
|
||
|
||
void CGuild::Chat(const char* c_pszText)
|
||
{
|
||
std::for_each(m_memberOnline.begin(), m_memberOnline.end(), FGuildChat(c_pszText));
|
||
|
||
TPacketGGGuild p1;
|
||
TPacketGGGuildChat p2;
|
||
|
||
p1.bHeader = HEADER_GG_GUILD;
|
||
p1.bSubHeader = GUILD_SUBHEADER_GG_CHAT;
|
||
p1.dwGuild = GetID();
|
||
strlcpy(p2.szText, c_pszText, sizeof(p2.szText));
|
||
|
||
P2P_MANAGER::instance().Send(&p1, sizeof(TPacketGGGuild));
|
||
P2P_MANAGER::instance().Send(&p2, sizeof(TPacketGGGuildChat));
|
||
}
|
||
|
||
LPCHARACTER CGuild::GetMasterCharacter()
|
||
{
|
||
return CHARACTER_MANAGER::instance().FindByPID(GetMasterPID());
|
||
}
|
||
|
||
void CGuild::Packet(const void* buf, int size)
|
||
{
|
||
for (itertype(m_memberOnline) it = m_memberOnline.begin(); it!=m_memberOnline.end();++it)
|
||
{
|
||
LPDESC d = (*it)->GetDesc();
|
||
|
||
if (d)
|
||
d->Packet(buf, size);
|
||
}
|
||
}
|
||
|
||
int CGuild::GetTotalLevel() const
|
||
{
|
||
int total = 0;
|
||
|
||
for (itertype(m_member) it = m_member.begin(); it != m_member.end(); ++it)
|
||
{
|
||
total += it->second.level;
|
||
}
|
||
|
||
return total;
|
||
}
|
||
|
||
bool CGuild::ChargeSP(LPCHARACTER ch, int iSP)
|
||
{
|
||
int gold = iSP * 100;
|
||
|
||
if (gold < iSP || ch->GetGold() < gold)
|
||
return false;
|
||
|
||
int iRemainSP = m_data.max_power - m_data.power;
|
||
|
||
if (iSP > iRemainSP)
|
||
{
|
||
iSP = iRemainSP;
|
||
gold = iSP * 100;
|
||
}
|
||
|
||
ch->PointChange(POINT_GOLD, -gold);
|
||
DBManager::instance().SendMoneyLog(MONEY_LOG_GUILD, 1, -gold);
|
||
|
||
SendDBSkillUpdate(iSP);
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> %u\xC0\xC7 \xBF\xEB\xBD\xC5\xB7\xC2\xC0\xBB \xC8\xB8\xBA\xB9\xC7\xCF\xBF\xB4\xBD\xC0\xB4\xCF\xB4\xD9."), iSP);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void CGuild::SkillUsableChange(DWORD dwSkillVnum, bool bUsable)
|
||
{
|
||
DWORD dwRealVnum = dwSkillVnum - GUILD_SKILL_START;
|
||
|
||
if (dwRealVnum >= GUILD_SKILL_COUNT)
|
||
return;
|
||
|
||
abSkillUsable[dwRealVnum] = bUsable;
|
||
|
||
// GUILD_SKILL_COOLTIME_BUG_FIX
|
||
SPDLOG_DEBUG("CGuild::SkillUsableChange(guild={}, skill={}, usable={})", GetName(), dwSkillVnum, bUsable);
|
||
// END_OF_GUILD_SKILL_COOLTIME_BUG_FIX
|
||
}
|
||
|
||
// GUILD_MEMBER_COUNT_BONUS
|
||
void CGuild::SetMemberCountBonus(int iBonus)
|
||
{
|
||
m_iMemberCountBonus = iBonus;
|
||
SPDLOG_DEBUG("GUILD_IS_FULL_BUG : Bonus set to {}(val:{})", iBonus, m_iMemberCountBonus);
|
||
}
|
||
|
||
void CGuild::BroadcastMemberCountBonus()
|
||
{
|
||
TPacketGGGuild p1;
|
||
|
||
p1.bHeader = HEADER_GG_GUILD;
|
||
p1.bSubHeader = GUILD_SUBHEADER_GG_SET_MEMBER_COUNT_BONUS;
|
||
p1.dwGuild = GetID();
|
||
|
||
P2P_MANAGER::instance().Send(&p1, sizeof(TPacketGGGuild));
|
||
P2P_MANAGER::instance().Send(&m_iMemberCountBonus, sizeof(int));
|
||
}
|
||
|
||
int CGuild::GetMaxMemberCount()
|
||
{
|
||
// GUILD_IS_FULL_BUG_FIX
|
||
if ( m_iMemberCountBonus < 0 || m_iMemberCountBonus > 18 )
|
||
m_iMemberCountBonus = 0;
|
||
// END_GUILD_IS_FULL_BUG_FIX
|
||
|
||
if ( LC_IsHongKong() == true )
|
||
{
|
||
quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetMasterPID());
|
||
|
||
if ( pPC != NULL )
|
||
{
|
||
if ( pPC->GetFlag("guild.is_unlimit_member") == 1 )
|
||
{
|
||
return INT_MAX;
|
||
}
|
||
}
|
||
}
|
||
|
||
return 32 + 2 * (m_data.level-1) + m_iMemberCountBonus;
|
||
}
|
||
// END_OF_GUILD_MEMBER_COUNT_BONUS
|
||
|
||
void CGuild::AdvanceLevel(int iLevel)
|
||
{
|
||
if (m_data.level == iLevel)
|
||
return;
|
||
|
||
m_data.level = std::min<BYTE>(GUILD_MAX_LEVEL, iLevel);
|
||
}
|
||
|
||
void CGuild::RequestDepositMoney(LPCHARACTER ch, int iGold)
|
||
{
|
||
if (false==ch->CanDeposit())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC0\xE1\xBD\xC3\xC8\xC4\xBF\xA1 \xC0\xCC\xBF\xEB\xC7\xD8\xC1\xD6\xBD\xCA\xBD\xC3\xBF\xC0"));
|
||
return;
|
||
}
|
||
|
||
if (ch->GetGold() < iGold)
|
||
return;
|
||
|
||
|
||
ch->PointChange(POINT_GOLD, -iGold);
|
||
|
||
TPacketGDGuildMoney p;
|
||
p.dwGuild = GetID();
|
||
p.iGold = iGold;
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_DEPOSIT_MONEY, 0, &p, sizeof(p));
|
||
|
||
char buf[64+1];
|
||
snprintf(buf, sizeof(buf), "%u %s", GetID(), GetName());
|
||
LogManager::instance().CharLog(ch, iGold, "GUILD_DEPOSIT", buf);
|
||
|
||
ch->UpdateDepositPulse();
|
||
SPDLOG_DEBUG("GUILD: DEPOSIT {}:{} player {}[{}] gold {}", GetName(), GetID(), ch->GetName(), ch->GetPlayerID(), iGold);
|
||
}
|
||
|
||
void CGuild::RequestWithdrawMoney(LPCHARACTER ch, int iGold)
|
||
{
|
||
if (false==ch->CanDeposit())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC0\xE1\xBD\xC3\xC8\xC4\xBF\xA1 \xC0\xCC\xBF\xEB\xC7\xD8\xC1\xD6\xBD\xCA\xBD\xC3\xBF\xC0"));
|
||
return;
|
||
}
|
||
|
||
if (ch->GetPlayerID() != GetMasterPID())
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xB1\xE6\xB5\xE5 \xB1\xDD\xB0\xED\xBF\xA1\xBC\xB1 \xB1\xE6\xB5\xE5\xC0\xE5\xB8\xB8 \xC3\xE2\xB1\xDD\xC7\xD2 \xBC\xF6 \xC0\xD6\xBD\xC0\xB4\xCF\xB4\xD9."));
|
||
return;
|
||
}
|
||
|
||
if (m_data.gold < iGold)
|
||
{
|
||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xB0\xA1\xC1\xF6\xB0\xED \xC0\xD6\xB4\xC2 \xB5\xB7\xC0\xCC \xBA\xCE\xC1\xB7\xC7\xD5\xB4\xCF\xB4\xD9."));
|
||
return;
|
||
}
|
||
|
||
TPacketGDGuildMoney p;
|
||
p.dwGuild = GetID();
|
||
p.iGold = iGold;
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_WITHDRAW_MONEY, 0, &p, sizeof(p));
|
||
|
||
ch->UpdateDepositPulse();
|
||
}
|
||
|
||
void CGuild::RecvMoneyChange(int iGold)
|
||
{
|
||
m_data.gold = iGold;
|
||
|
||
TPacketGCGuild p;
|
||
p.header = HEADER_GC_GUILD;
|
||
p.size = sizeof(p) + sizeof(int);
|
||
p.subheader = GUILD_SUBHEADER_GC_MONEY_CHANGE;
|
||
|
||
for (itertype(m_memberOnline) it = m_memberOnline.begin(); it != m_memberOnline.end(); ++it)
|
||
{
|
||
LPCHARACTER ch = *it;
|
||
LPDESC d = ch->GetDesc();
|
||
d->RawPacket(&p, sizeof(p));
|
||
d->Packet(&iGold, sizeof(int));
|
||
}
|
||
}
|
||
|
||
void CGuild::RecvWithdrawMoneyGive(int iChangeGold)
|
||
{
|
||
LPCHARACTER ch = GetMasterCharacter();
|
||
|
||
if (ch)
|
||
{
|
||
ch->PointChange(POINT_GOLD, iChangeGold);
|
||
SPDLOG_DEBUG("GUILD: WITHDRAW {}:{} player {}[{}] gold {}", GetName(), GetID(), ch->GetName(), ch->GetPlayerID(), iChangeGold);
|
||
}
|
||
|
||
TPacketGDGuildMoneyWithdrawGiveReply p;
|
||
p.dwGuild = GetID();
|
||
p.iChangeGold = iChangeGold;
|
||
p.bGiveSuccess = ch ? 1 : 0;
|
||
db_clientdesc->DBPacket(HEADER_GD_GUILD_WITHDRAW_MONEY_GIVE_REPLY, 0, &p, sizeof(p));
|
||
}
|
||
|
||
bool CGuild::HasLand()
|
||
{
|
||
return building::CManager::instance().FindLandByGuild(GetID()) != NULL;
|
||
}
|
||
|
||
// GUILD_JOIN_BUG_FIX
|
||
/// <20><><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> event <20><><EFBFBD><EFBFBD>
|
||
EVENTINFO(TInviteGuildEventInfo)
|
||
{
|
||
DWORD dwInviteePID; ///< <20>ʴ<EFBFBD><CAB4><EFBFBD><EFBFBD><EFBFBD> character <20><> PID
|
||
DWORD dwGuildID; ///< <20>ʴ<EFBFBD><CAB4><EFBFBD> Guild <20><> ID
|
||
|
||
TInviteGuildEventInfo()
|
||
: dwInviteePID( 0 )
|
||
, dwGuildID( 0 )
|
||
{
|
||
}
|
||
};
|
||
|
||
/**
|
||
* <20><><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> event callback <20>Լ<EFBFBD>.
|
||
* event <20><> <20>ߵ<EFBFBD><DFB5>ϸ<EFBFBD> <20>ʴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3><EFBFBD>Ѵ<EFBFBD>.
|
||
*/
|
||
EVENTFUNC( GuildInviteEvent )
|
||
{
|
||
TInviteGuildEventInfo *pInfo = dynamic_cast<TInviteGuildEventInfo*>( event->info );
|
||
|
||
if ( pInfo == NULL )
|
||
{
|
||
SPDLOG_ERROR("GuildInviteEvent> <Factor> Null pointer" );
|
||
return 0;
|
||
}
|
||
|
||
CGuild* pGuild = CGuildManager::instance().FindGuild( pInfo->dwGuildID );
|
||
|
||
if ( pGuild )
|
||
{
|
||
SPDLOG_DEBUG("GuildInviteEvent {}", pGuild->GetName() );
|
||
pGuild->InviteDeny( pInfo->dwInviteePID );
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
void CGuild::Invite( LPCHARACTER pchInviter, LPCHARACTER pchInvitee )
|
||
{
|
||
if (quest::CQuestManager::instance().GetPCForce(pchInviter->GetPlayerID())->IsRunning() == true)
|
||
{
|
||
pchInviter->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBB\xF3\xB4\xEB\xB9\xE6\xC0\xCC \xC3\xCA\xB4\xEB \xBD\xC5\xC3\xBB\xC0\xBB \xB9\xDE\xC0\xBB \xBC\xF6 \xBE\xF8\xB4\xC2 \xBB\xF3\xC5\xC2\xC0\xD4\xB4\xCF\xB4\xD9."));
|
||
return;
|
||
}
|
||
|
||
|
||
if (quest::CQuestManager::instance().GetPCForce(pchInvitee->GetPlayerID())->IsRunning() == true)
|
||
return;
|
||
|
||
if ( pchInvitee->IsBlockMode( BLOCK_GUILD_INVITE ) )
|
||
{
|
||
pchInviter->ChatPacket( CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBB\xF3\xB4\xEB\xB9\xE6\xC0\xCC \xB1\xE6\xB5\xE5 \xC3\xCA\xB4\xEB \xB0\xC5\xBA\xCE \xBB\xF3\xC5\xC2\xC0\xD4\xB4\xCF\xB4\xD9.") );
|
||
return;
|
||
}
|
||
else if ( !HasGradeAuth( GetMember( pchInviter->GetPlayerID() )->grade, GUILD_AUTH_ADD_MEMBER ) )
|
||
{
|
||
pchInviter->ChatPacket( CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xB1\xE6\xB5\xE5\xBF\xF8\xC0\xBB \xC3\xCA\xB4\xEB\xC7\xD2 \xB1\xC7\xC7\xD1\xC0\xCC \xBE\xF8\xBD\xC0\xB4\xCF\xB4\xD9.") );
|
||
return;
|
||
}
|
||
else if ( pchInvitee->GetEmpire() != pchInviter->GetEmpire() )
|
||
{
|
||
pchInviter->ChatPacket( CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xB4\xD9\xB8\xA5 \xC1\xA6\xB1\xB9 \xBB\xE7\xB6\xF7\xC0\xBB \xB1\xE6\xB5\xE5\xBF\xA1 \xC3\xCA\xB4\xEB\xC7\xD2 \xBC\xF6 \xBE\xF8\xBD\xC0\xB4\xCF\xB4\xD9.") );
|
||
return;
|
||
}
|
||
|
||
GuildJoinErrCode errcode = VerifyGuildJoinableCondition( pchInvitee );
|
||
switch ( errcode )
|
||
{
|
||
case GERR_NONE: break;
|
||
case GERR_WITHDRAWPENALTY:
|
||
pchInviter->ChatPacket( CHAT_TYPE_INFO,
|
||
LC_TEXT("<\xB1\xE6\xB5\xE5> \xC5\xBB\xC5\xF0\xC7\xD1 \xC8\xC4 %d\xC0\xCF\xC0\xCC \xC1\xF6\xB3\xAA\xC1\xF6 \xBE\xCA\xC0\xBA \xBB\xE7\xB6\xF7\xC0\xBA \xB1\xE6\xB5\xE5\xBF\xA1 \xC3\xCA\xB4\xEB\xC7\xD2 \xBC\xF6 \xBE\xF8\xBD\xC0\xB4\xCF\xB4\xD9."),
|
||
quest::CQuestManager::instance().GetEventFlag( "guild_withdraw_delay" ) );
|
||
return;
|
||
case GERR_COMMISSIONPENALTY:
|
||
pchInviter->ChatPacket( CHAT_TYPE_INFO,
|
||
LC_TEXT("<\xB1\xE6\xB5\xE5> \xB1\xE6\xB5\xE5\xB8\xA6 \xC7\xD8\xBB\xEA\xC7\xD1 \xC1\xF6 %d\xC0\xCF\xC0\xCC \xC1\xF6\xB3\xAA\xC1\xF6 \xBE\xCA\xC0\xBA \xBB\xE7\xB6\xF7\xC0\xBA \xB1\xE6\xB5\xE5\xBF\xA1 \xC3\xCA\xB4\xEB\xC7\xD2 \xBC\xF6 \xBE\xF8\xBD\xC0\xB4\xCF\xB4\xD9."),
|
||
quest::CQuestManager::instance().GetEventFlag( "guild_disband_delay") );
|
||
return;
|
||
case GERR_ALREADYJOIN: pchInviter->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBB\xF3\xB4\xEB\xB9\xE6\xC0\xCC \xC0\xCC\xB9\xCC \xB4\xD9\xB8\xA5 \xB1\xE6\xB5\xE5\xBF\xA1 \xBC\xD3\xC7\xD8\xC0\xD6\xBD\xC0\xB4\xCF\xB4\xD9.")); return;
|
||
case GERR_GUILDISFULL: pchInviter->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC3\xD6\xB4\xEB \xB1\xE6\xB5\xE5\xBF\xF8 \xBC\xF6\xB8\xA6 \xC3\xCA\xB0\xFA\xC7\xDF\xBD\xC0\xB4\xCF\xB4\xD9.")); return;
|
||
case GERR_GUILD_IS_IN_WAR : pchInviter->ChatPacket( CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC7\xF6\xC0\xE7 \xB1\xE6\xB5\xE5\xB0\xA1 \xC0\xFC\xC0\xEF \xC1\xDF \xC0\xD4\xB4\xCF\xB4\xD9.") ); return;
|
||
case GERR_INVITE_LIMIT : pchInviter->ChatPacket( CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC7\xF6\xC0\xE7 \xBD\xC5\xB1\xD4 \xB0\xA1\xC0\xD4 \xC1\xA6\xC7\xD1 \xBB\xF3\xC5\xC2 \xC0\xD4\xB4\xCF\xB4\xD9.") ); return;
|
||
|
||
default: SPDLOG_ERROR("ignore guild join error({})", (int) errcode ); return;
|
||
}
|
||
|
||
if ( m_GuildInviteEventMap.end() != m_GuildInviteEventMap.find( pchInvitee->GetPlayerID() ) )
|
||
return;
|
||
|
||
//
|
||
// <20>̺<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
|
||
//
|
||
TInviteGuildEventInfo* pInfo = AllocEventInfo<TInviteGuildEventInfo>();
|
||
pInfo->dwInviteePID = pchInvitee->GetPlayerID();
|
||
pInfo->dwGuildID = GetID();
|
||
|
||
m_GuildInviteEventMap.insert(EventMap::value_type(pchInvitee->GetPlayerID(), event_create(GuildInviteEvent, pInfo, PASSES_PER_SEC(10))));
|
||
|
||
//
|
||
// <20>ʴ<EFBFBD> <20><EFBFBD> character <20><><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD>
|
||
//
|
||
|
||
DWORD gid = GetID();
|
||
|
||
TPacketGCGuild p;
|
||
p.header = HEADER_GC_GUILD;
|
||
p.size = sizeof(p) + sizeof(DWORD) + GUILD_NAME_MAX_LEN + 1;
|
||
p.subheader = GUILD_SUBHEADER_GC_GUILD_INVITE;
|
||
|
||
TEMP_BUFFER buf;
|
||
buf.write( &p, sizeof(p) );
|
||
buf.write( &gid, sizeof(DWORD) );
|
||
buf.write( GetName(), GUILD_NAME_MAX_LEN + 1 );
|
||
|
||
pchInvitee->GetDesc()->Packet( buf.read_peek(), buf.size() );
|
||
}
|
||
|
||
void CGuild::InviteAccept( LPCHARACTER pchInvitee )
|
||
{
|
||
EventMap::iterator itFind = m_GuildInviteEventMap.find( pchInvitee->GetPlayerID() );
|
||
if ( itFind == m_GuildInviteEventMap.end() )
|
||
{
|
||
SPDLOG_DEBUG("GuildInviteAccept from not invited character(invite guild: {}, invitee: {})", GetName(), pchInvitee->GetName() );
|
||
return;
|
||
}
|
||
|
||
event_cancel( &itFind->second );
|
||
m_GuildInviteEventMap.erase( itFind );
|
||
|
||
GuildJoinErrCode errcode = VerifyGuildJoinableCondition( pchInvitee );
|
||
switch ( errcode )
|
||
{
|
||
case GERR_NONE: break;
|
||
case GERR_WITHDRAWPENALTY:
|
||
pchInvitee->ChatPacket( CHAT_TYPE_INFO,
|
||
LC_TEXT("<\xB1\xE6\xB5\xE5> \xC5\xBB\xC5\xF0\xC7\xD1 \xC8\xC4 %d\xC0\xCF\xC0\xCC \xC1\xF6\xB3\xAA\xC1\xF6 \xBE\xCA\xC0\xBA \xBB\xE7\xB6\xF7\xC0\xBA \xB1\xE6\xB5\xE5\xBF\xA1 \xC3\xCA\xB4\xEB\xC7\xD2 \xBC\xF6 \xBE\xF8\xBD\xC0\xB4\xCF\xB4\xD9."),
|
||
quest::CQuestManager::instance().GetEventFlag( "guild_withdraw_delay" ) );
|
||
return;
|
||
case GERR_COMMISSIONPENALTY:
|
||
pchInvitee->ChatPacket( CHAT_TYPE_INFO,
|
||
LC_TEXT("<\xB1\xE6\xB5\xE5> \xB1\xE6\xB5\xE5\xB8\xA6 \xC7\xD8\xBB\xEA\xC7\xD1 \xC1\xF6 %d\xC0\xCF\xC0\xCC \xC1\xF6\xB3\xAA\xC1\xF6 \xBE\xCA\xC0\xBA \xBB\xE7\xB6\xF7\xC0\xBA \xB1\xE6\xB5\xE5\xBF\xA1 \xC3\xCA\xB4\xEB\xC7\xD2 \xBC\xF6 \xBE\xF8\xBD\xC0\xB4\xCF\xB4\xD9."),
|
||
quest::CQuestManager::instance().GetEventFlag( "guild_disband_delay") );
|
||
return;
|
||
case GERR_ALREADYJOIN: pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xBB\xF3\xB4\xEB\xB9\xE6\xC0\xCC \xC0\xCC\xB9\xCC \xB4\xD9\xB8\xA5 \xB1\xE6\xB5\xE5\xBF\xA1 \xBC\xD3\xC7\xD8\xC0\xD6\xBD\xC0\xB4\xCF\xB4\xD9.")); return;
|
||
case GERR_GUILDISFULL: pchInvitee->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC3\xD6\xB4\xEB \xB1\xE6\xB5\xE5\xBF\xF8 \xBC\xF6\xB8\xA6 \xC3\xCA\xB0\xFA\xC7\xDF\xBD\xC0\xB4\xCF\xB4\xD9.")); return;
|
||
case GERR_GUILD_IS_IN_WAR : pchInvitee->ChatPacket( CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC7\xF6\xC0\xE7 \xB1\xE6\xB5\xE5\xB0\xA1 \xC0\xFC\xC0\xEF \xC1\xDF \xC0\xD4\xB4\xCF\xB4\xD9.") ); return;
|
||
case GERR_INVITE_LIMIT : pchInvitee->ChatPacket( CHAT_TYPE_INFO, LC_TEXT("<\xB1\xE6\xB5\xE5> \xC7\xF6\xC0\xE7 \xBD\xC5\xB1\xD4 \xB0\xA1\xC0\xD4 \xC1\xA6\xC7\xD1 \xBB\xF3\xC5\xC2 \xC0\xD4\xB4\xCF\xB4\xD9.") ); return;
|
||
|
||
default: SPDLOG_ERROR("ignore guild join error({})", (int) errcode); return;
|
||
}
|
||
|
||
RequestAddMember( pchInvitee, 15 );
|
||
}
|
||
|
||
void CGuild::InviteDeny( DWORD dwPID )
|
||
{
|
||
EventMap::iterator itFind = m_GuildInviteEventMap.find( dwPID );
|
||
if ( itFind == m_GuildInviteEventMap.end() )
|
||
{
|
||
SPDLOG_DEBUG("GuildInviteDeny from not invited character(invite guild: {}, invitee PID: {})", GetName(), dwPID );
|
||
return;
|
||
}
|
||
|
||
event_cancel( &itFind->second );
|
||
m_GuildInviteEventMap.erase( itFind );
|
||
}
|
||
|
||
CGuild::GuildJoinErrCode CGuild::VerifyGuildJoinableCondition( const LPCHARACTER pchInvitee )
|
||
{
|
||
if ( get_global_time() - pchInvitee->GetQuestFlag( "guild_manage.new_withdraw_time" )
|
||
< CGuildManager::instance().GetWithdrawDelay() )
|
||
return GERR_WITHDRAWPENALTY;
|
||
else if ( get_global_time() - pchInvitee->GetQuestFlag( "guild_manage.new_disband_time" )
|
||
< CGuildManager::instance().GetDisbandDelay() )
|
||
return GERR_COMMISSIONPENALTY;
|
||
else if ( pchInvitee->GetGuild() )
|
||
return GERR_ALREADYJOIN;
|
||
else if ( GetMemberCount() >= GetMaxMemberCount() )
|
||
{
|
||
SPDLOG_DEBUG("GuildName = {}, GetMemberCount() = {}, GetMaxMemberCount() = {} (32 + MAX(level({})-10, 0) * 2 + bonus({})",
|
||
GetName(), GetMemberCount(), GetMaxMemberCount(), m_data.level, m_iMemberCountBonus);
|
||
return GERR_GUILDISFULL;
|
||
}
|
||
else if ( UnderAnyWar() != 0 )
|
||
{
|
||
return GERR_GUILD_IS_IN_WAR;
|
||
}
|
||
else if ( LC_IsBrazil() == true )
|
||
{
|
||
std::unique_ptr<SQLMsg> pMsg( DBManager::instance().DirectQuery("SELECT value FROM guild_invite_limit WHERE id=%d", GetID()) );
|
||
|
||
if ( pMsg->Get()->uiNumRows > 0 )
|
||
{
|
||
MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);
|
||
time_t limit_time=0;
|
||
str_to_number( limit_time, row[0] );
|
||
|
||
if ( test_server == true )
|
||
{
|
||
limit_time += quest::CQuestManager::instance().GetEventFlag("guild_invite_limit") * 60;
|
||
}
|
||
else
|
||
{
|
||
limit_time += quest::CQuestManager::instance().GetEventFlag("guild_invite_limit") * 24 * 60 * 60;
|
||
}
|
||
|
||
if ( get_global_time() < limit_time ) return GERR_INVITE_LIMIT;
|
||
}
|
||
}
|
||
|
||
return GERR_NONE;
|
||
}
|
||
// END_OF_GUILD_JOIN_BUG_FIX
|
||
|
||
bool CGuild::ChangeMasterTo(DWORD dwPID)
|
||
{
|
||
if ( GetMember(dwPID) == NULL ) return false;
|
||
|
||
TPacketChangeGuildMaster p;
|
||
p.dwGuildID = GetID();
|
||
p.idFrom = GetMasterPID();
|
||
p.idTo = dwPID;
|
||
|
||
db_clientdesc->DBPacket(HEADER_GD_REQ_CHANGE_GUILD_MASTER, 0, &p, sizeof(p));
|
||
|
||
return true;
|
||
}
|
||
|
||
void CGuild::SendGuildDataUpdateToAllMember(SQLMsg* pmsg)
|
||
{
|
||
TGuildMemberOnlineContainer::iterator iter = m_memberOnline.begin();
|
||
|
||
for (; iter != m_memberOnline.end(); iter++ )
|
||
{
|
||
SendGuildInfoPacket(*iter);
|
||
SendAllGradePacket(*iter);
|
||
}
|
||
}
|
||
|