639 lines
20 KiB
C++
639 lines
20 KiB
C++
#include "precompile.h"
|
|
|
|
#include <a8/openssl.h>
|
|
#include <a8/mutable_xobject.h>
|
|
|
|
#include "guild.h"
|
|
#include "guildmgr.h"
|
|
#include "cs_msgid.pb.h"
|
|
#include "cs_proto.pb.h"
|
|
#include "ss_proto.pb.h"
|
|
#include "IMListener.h"
|
|
#include "asynctaskmgr.h"
|
|
#include "dbengine.h"
|
|
#include "jsondatamgr.h"
|
|
#include "player.h"
|
|
#include "playermgr.h"
|
|
#include "app.h"
|
|
#include "typeconvert.h"
|
|
|
|
#include "framework/cpp/httpclientpool.h"
|
|
|
|
class AsyncGuildTask
|
|
{
|
|
public:
|
|
int socket_handle = 0;
|
|
long long guild_id = 0;
|
|
time_t time = 0;
|
|
ss::SS_IM_ForwardGuildCMMsg forward_msg;
|
|
|
|
virtual ~AsyncGuildTask() {}
|
|
virtual void Execute(Guild* guild) {}
|
|
virtual void OnError() {}
|
|
};
|
|
|
|
class CMGuildInfoTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildInfo cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildInfo(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
};
|
|
|
|
class CMGuildJoinTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildJoin cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildJoin(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
};
|
|
|
|
class CMGuildAgreeTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildAgree cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildAgree(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
|
|
};
|
|
|
|
class CMGuildKickTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildKick cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildKick(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
|
|
};
|
|
|
|
class CMGuildQuitTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildQuit cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildQuit(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
|
|
};
|
|
|
|
class CMGuildDismissTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildDismiss cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildDismiss(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
|
|
};
|
|
|
|
class CMGuildRenameTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildRename cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildRename(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
|
|
};
|
|
|
|
class CMGuildMemberListTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildMemberList cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildMemberList(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
|
|
};
|
|
|
|
class CMGuildLogTask : public AsyncGuildTask
|
|
{
|
|
private:
|
|
cs::CMGuildLog cmmsg;
|
|
|
|
virtual void Execute(Guild* guild) override
|
|
{
|
|
guild->_CMGuildLog(socket_handle, forward_msg.context(), cmmsg);
|
|
}
|
|
|
|
};
|
|
|
|
void GuildMgr::Init()
|
|
{
|
|
|
|
}
|
|
|
|
void GuildMgr::UnInit()
|
|
{
|
|
|
|
}
|
|
|
|
void GuildMgr::_SS_IM_ForwardGuildCMMsg(f8::MsgHdr& hdr, const ss::SS_IM_ForwardGuildCMMsg& msg)
|
|
{
|
|
if (msg.msgid() < cs::CMMessageId_e::_CMGuildMsgBegin ||
|
|
msg.msgid() > cs::CMMessageId_e::_CMGuildMsgEnd) {
|
|
return;
|
|
}
|
|
if (!IsValidGuildId(msg.context().user_info().base_data().guild_id())) {
|
|
ss::SS_CommonError respmsg;
|
|
respmsg.set_errcode(SERVER_INTERNAL_ERROR);
|
|
respmsg.set_errmsg("服务器内部错误");
|
|
ForwardGuildSMMsg(hdr.socket_handle, msg.context(), msg.msgid(), respmsg);
|
|
return;
|
|
}
|
|
switch (msg.msgid()) {
|
|
case cs::CMMessageId_e::_CMGuildInfo:
|
|
{
|
|
cs::CMGuildInfo cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
CMGuildInfoTask* task = new CMGuildInfoTask;
|
|
CreateAsyncTask(hdr.socket_handle, cmmsg.guild_id(), task);
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildCreate:
|
|
{
|
|
cs::CMGuildCreate cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
_CMGuildCreate(hdr.socket_handle, msg.context(), cmmsg);
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildJoin:
|
|
{
|
|
cs::CMGuildJoin cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
CMGuildJoinTask* task = new CMGuildJoinTask;
|
|
CreateAsyncTask(hdr.socket_handle, cmmsg.guild_id(), task);
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildAgree:
|
|
{
|
|
cs::CMGuildAgree cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildKick:
|
|
{
|
|
cs::CMGuildKick cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildQuit:
|
|
{
|
|
cs::CMGuildQuit cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildDismiss:
|
|
{
|
|
cs::CMGuildDismiss cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildRename:
|
|
{
|
|
cs::CMGuildRename cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildSearch:
|
|
{
|
|
cs::CMGuildSearch cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
_CMGuildSearch(hdr.socket_handle, msg.context(), cmmsg);
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildRank:
|
|
{
|
|
cs::CMGuildRank cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
_CMGuildRank(hdr.socket_handle, msg.context(), cmmsg);
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildMemberList:
|
|
{
|
|
cs::CMGuildMemberList cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
}
|
|
break;
|
|
case cs::CMMessageId_e::_CMGuildLog:
|
|
{
|
|
cs::CMGuildLog cmmsg;
|
|
cmmsg.ParseFromArray(msg.payload().data(), msg.payload().size());
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void GuildMgr::_CMGuildCreate(int socket_handle, const ss::MFIMMsgConext& context, const cs::CMGuildCreate& msg)
|
|
{
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(socket_handle);
|
|
if (!hum) {
|
|
return;
|
|
}
|
|
Guild* guild = GetGuild(context.user_info().base_data().guild_id());
|
|
if (guild) {
|
|
cs::SMGuildCreate respmsg;
|
|
respmsg.set_errcode(1);
|
|
respmsg.set_errmsg("公会id已经存在");
|
|
ForwardGuildSMMsg(socket_handle, context, respmsg);
|
|
return;
|
|
}
|
|
std::string ip;
|
|
int port = 0;
|
|
JsonDataMgr::Instance()->GetRankServerConf(ip, port);
|
|
|
|
struct MsgContext
|
|
{
|
|
int socket_handle = 0;
|
|
ss::MFIMMsgConext context;
|
|
cs::CMGuildCreate msg;
|
|
long long guild_id = 0;
|
|
};
|
|
MsgContext* msg_context = new MsgContext;
|
|
msg_context->socket_handle = socket_handle;
|
|
msg_context->context = context;
|
|
msg_context->msg = msg;
|
|
msg_context->guild_id = App::Instance()->NewUUID();
|
|
a8::MutableXObject* params = a8::MutableXObject::NewObject();
|
|
params->SetVal("gameid", hum->gameid);
|
|
params->SetVal("guild_id", msg_context->guild_id);
|
|
params->SetVal("guild_name", msg.guild_name());
|
|
params->SetVal("guild_badge", msg.guild_badge());
|
|
params->SetVal("guild_lv", 1);
|
|
params->SetVal("guild_exp", 0);
|
|
params->SetVal("guild_declaration", msg.guild_declaration());
|
|
params->SetVal("owner_id", hum->AccountId());
|
|
params->SetVal("owner_name", hum->NickName());
|
|
params->SetVal("owner_avatar_url", hum->AvatarUrl());
|
|
f8::HttpClientPool::Instance()->HttpGet
|
|
(
|
|
a8::XParams()
|
|
.SetSender(msg_context),
|
|
[] (a8::XParams& param, a8::XObject& data)
|
|
{
|
|
MsgContext* msg_context = (MsgContext*)param.sender.GetUserData();
|
|
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(msg_context->socket_handle);
|
|
if (hum) {
|
|
cs::SMGuildCreate respmsg;
|
|
hum->SendMsg(respmsg);
|
|
}
|
|
|
|
A8_SAFE_DELETE(msg_context);
|
|
},
|
|
[] (a8::XParams& param, const std::string& response)
|
|
{
|
|
MsgContext* msg_context = (MsgContext*)param.sender.GetUserData();
|
|
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(msg_context->socket_handle);
|
|
if (hum) {
|
|
cs::SMGuildCreate respmsg;
|
|
hum->SendMsg(respmsg);
|
|
}
|
|
|
|
A8_SAFE_DELETE(msg_context);
|
|
},
|
|
a8::Format("http://%s:%d/webapp/index.php?c=Guild&a=create", {ip, port}).c_str(),
|
|
*params,
|
|
msg_context->guild_id
|
|
);
|
|
delete params;
|
|
}
|
|
|
|
void GuildMgr::_CMGuildSearch(int socket_handle, const ss::MFIMMsgConext& context, const cs::CMGuildSearch& msg)
|
|
{
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(socket_handle);
|
|
if (!hum) {
|
|
return;
|
|
}
|
|
|
|
std::string ip;
|
|
int port = 0;
|
|
JsonDataMgr::Instance()->GetRankServerConf(ip, port);
|
|
|
|
struct MsgContext
|
|
{
|
|
int socket_handle = 0;
|
|
ss::MFIMMsgConext context;
|
|
cs::CMGuildSearch msg;
|
|
};
|
|
MsgContext* msg_context = new MsgContext;
|
|
msg_context->socket_handle = socket_handle;
|
|
msg_context->context = context;
|
|
msg_context->msg = msg;
|
|
|
|
a8::MutableXObject* params = a8::MutableXObject::NewObject();
|
|
params->SetVal("gameid", hum->gameid);
|
|
params->SetVal("guild_name", msg.guild_name());
|
|
params->SetVal("curr_page", msg.paging().curr_page());
|
|
params->SetVal("page_size", msg.paging().page_size());
|
|
f8::HttpClientPool::Instance()->HttpGet
|
|
(
|
|
a8::XParams(),
|
|
[] (a8::XParams& param, a8::XObject& data)
|
|
{
|
|
MsgContext* msg_context = (MsgContext*)param.sender.GetUserData();
|
|
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(msg_context->socket_handle);
|
|
if (hum) {
|
|
cs::SMGuildSearch respmsg;
|
|
respmsg.set_errcode(data.At("errcode")->AsXValue());
|
|
respmsg.set_errmsg(data.At("errmsg")->AsXValue());
|
|
if (respmsg.errcode() == 0) {
|
|
TypeConvert::Convert(*data.At("paging"), respmsg.mutable_paging());
|
|
auto guild_list = data.At("guild_list");
|
|
for (int i = 0; i < guild_list->Size(); ++i) {
|
|
auto guild = guild_list->At(i);
|
|
auto guild_pb = respmsg.add_guild_list();
|
|
TypeConvert::Convert(*guild, guild_pb);
|
|
}
|
|
}
|
|
hum->SendMsg(respmsg);
|
|
}
|
|
|
|
A8_SAFE_DELETE(msg_context);
|
|
},
|
|
[] (a8::XParams& param, const std::string& response)
|
|
{
|
|
MsgContext* msg_context = (MsgContext*)param.sender.GetUserData();
|
|
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(msg_context->socket_handle);
|
|
if (hum) {
|
|
cs::SMGuildSearch respmsg;
|
|
respmsg.set_errcode(1);
|
|
respmsg.set_errmsg("");
|
|
hum->SendMsg(respmsg);
|
|
}
|
|
|
|
A8_SAFE_DELETE(msg_context);
|
|
},
|
|
a8::Format("http://%s:%d/webapp/index.php?c=Guild&a=search", {ip, port}).c_str(),
|
|
*params,
|
|
rand()
|
|
);
|
|
delete params;
|
|
}
|
|
|
|
void GuildMgr::_CMGuildRank(int socket_handle, const ss::MFIMMsgConext& context, const cs::CMGuildRank& msg)
|
|
{
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(socket_handle);
|
|
if (!hum) {
|
|
return;
|
|
}
|
|
|
|
std::string ip;
|
|
int port = 0;
|
|
JsonDataMgr::Instance()->GetRankServerConf(ip, port);
|
|
|
|
struct MsgContext
|
|
{
|
|
int socket_handle = 0;
|
|
ss::MFIMMsgConext context;
|
|
cs::CMGuildRank msg;
|
|
};
|
|
MsgContext* msg_context = new MsgContext;
|
|
msg_context->socket_handle = socket_handle;
|
|
msg_context->context = context;
|
|
msg_context->msg = msg;
|
|
|
|
a8::MutableXObject* params = a8::MutableXObject::NewObject();
|
|
params->SetVal("gameid", hum->gameid);
|
|
f8::HttpClientPool::Instance()->HttpGet
|
|
(
|
|
a8::XParams(),
|
|
[] (a8::XParams& param, a8::XObject& data)
|
|
{
|
|
MsgContext* msg_context = (MsgContext*)param.sender.GetUserData();
|
|
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(msg_context->socket_handle);
|
|
if (hum) {
|
|
cs::SMGuildRank respmsg;
|
|
respmsg.set_errcode(data.At("errcode")->AsXValue());
|
|
respmsg.set_errmsg(data.At("errmsg")->AsXValue());
|
|
if (respmsg.errcode() == 0) {
|
|
TypeConvert::Convert(*data.At("paging"), respmsg.mutable_paging());
|
|
auto guild_list = data.At("guild_list");
|
|
for (int i = 0; i < guild_list->Size(); ++i) {
|
|
auto guild = guild_list->At(i);
|
|
auto guild_pb = respmsg.add_guild_list();
|
|
TypeConvert::Convert(*guild, guild_pb);
|
|
}
|
|
}
|
|
hum->SendMsg(respmsg);
|
|
}
|
|
|
|
A8_SAFE_DELETE(msg_context);
|
|
},
|
|
[] (a8::XParams& param, const std::string& response)
|
|
{
|
|
MsgContext* msg_context = (MsgContext*)param.sender.GetUserData();
|
|
|
|
Player* hum = PlayerMgr::Instance()->GetPlayerBySocket(msg_context->socket_handle);
|
|
if (hum) {
|
|
cs::SMGuildRank respmsg;
|
|
respmsg.set_errcode(1);
|
|
respmsg.set_errmsg("");
|
|
hum->SendMsg(respmsg);
|
|
}
|
|
|
|
A8_SAFE_DELETE(msg_context);
|
|
},
|
|
a8::Format("http://%s:%d/webapp/index.php?c=Guild&a=rank", {ip, port}).c_str(),
|
|
*params,
|
|
rand()
|
|
);
|
|
delete params;
|
|
}
|
|
|
|
void GuildMgr::CreateAsyncTask(int socket_handle, long long guild_id, AsyncGuildTask* task)
|
|
{
|
|
Guild* guild = GetGuild(guild_id);
|
|
if (guild) {
|
|
task->Execute(guild);
|
|
delete task;
|
|
return;
|
|
}
|
|
task->socket_handle = socket_handle;
|
|
task->guild_id = guild_id;
|
|
task->time = App::Instance()->nowtime;
|
|
auto itr = task_hash_.find(guild_id);
|
|
if (itr != task_hash_.end()) {
|
|
itr->second.push_back(task);
|
|
} else {
|
|
task_hash_[guild_id] = std::list<AsyncGuildTask*>({task});
|
|
LoadGuild(guild_id);
|
|
}
|
|
}
|
|
|
|
void GuildMgr::LoadGuild(long long guild_id)
|
|
{
|
|
if (GetGuild(guild_id)) {
|
|
return;
|
|
}
|
|
if (pending_guild_hash_.find(guild_id) != pending_guild_hash_.end()) {
|
|
return;
|
|
}
|
|
pending_guild_hash_.insert(guild_id);
|
|
|
|
auto on_ok =
|
|
[] (a8::XParams& param, const f8::DataSet* data_set)
|
|
{
|
|
GuildMgr::Instance()->pending_guild_hash_.erase(param.sender);
|
|
if (data_set) {
|
|
for (auto& row : *data_set) {
|
|
GuildMgr::Instance()->CreateGuild
|
|
(
|
|
a8::XValue(row[0]), //gameid
|
|
a8::XValue(row[1]), //guild_id
|
|
row[3], //guild_name
|
|
a8::XValue(row[4]), //guild_lv
|
|
a8::XValue(row[5]), //guild_exp
|
|
a8::XValue(row[6]), //guild_badge
|
|
a8::XValue(row[7]), //guild_apply_num
|
|
row[8], //guild_members
|
|
row[9], //guild_notice
|
|
row[10], //guild_declaration
|
|
row[11], //guild_log
|
|
row[12], //owner_id
|
|
row[13], //owner_name
|
|
row[14], //owner_avatar_url
|
|
row[15], //creator_id
|
|
row[16], //creator_name
|
|
row[17], //creator_avatar_url
|
|
row[18], //guild_data
|
|
a8::XValue(19), //guild_status
|
|
a8::XValue(20) //createtime
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
auto on_error =
|
|
[] (a8::XParams& param, int error_code, const std::string& error_msg)
|
|
{
|
|
GuildMgr::Instance()->pending_guild_hash_.erase(param.sender);
|
|
auto itr = GuildMgr::Instance()->task_hash_.find(param.sender);
|
|
if (itr != GuildMgr::Instance()->task_hash_.end()) {
|
|
for (auto task : itr->second) {
|
|
task->OnError();
|
|
delete task;
|
|
}
|
|
GuildMgr::Instance()->task_hash_.erase(itr);
|
|
}
|
|
};
|
|
|
|
a8::XObject conn_info = DBEngine::Instance()->GetConnInfo(guild_id);
|
|
DBEngine::Instance()->ExecAsyncQuery
|
|
(
|
|
conn_info,
|
|
"SELECT gameid, guild_id, guild_name, guild_lv, guild_exp, guild_badge, guild_apply_num, "
|
|
" guild_members, guild_notice, guild_declaration, guild_log, "
|
|
" owner_id, owner_name, owner_avatar_url, "
|
|
" creator_id, creator_name, creator_avatar_url, guild_data, guild_status, createtime "
|
|
"WHERE guild_id=%d;",
|
|
{
|
|
guild_id
|
|
},
|
|
a8::XParams()
|
|
.SetSender(guild_id),
|
|
on_ok,
|
|
on_error,
|
|
guild_id
|
|
);
|
|
}
|
|
|
|
bool GuildMgr::IsValidGuildId(long long guild_id)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Guild* GuildMgr::GetGuild(long long guild_id)
|
|
{
|
|
auto itr = id_hash_.find(guild_id);
|
|
return itr != id_hash_.end() ? itr->second : nullptr;
|
|
}
|
|
|
|
void GuildMgr::ForwardGuildSMMsg(int socket_handle,
|
|
const ss::MFIMMsgConext& context,
|
|
int msgid,
|
|
const ::google::protobuf::Message& smmsg)
|
|
{
|
|
ss::SS_IM_ForwardGuildSMMsg msg;
|
|
*msg.mutable_context() = context;
|
|
msg.set_msgid(msgid);
|
|
smmsg.SerializeToString(msg.mutable_payload());
|
|
IMListener::Instance()->SendMsg(socket_handle, msg);
|
|
}
|
|
|
|
void GuildMgr::CreateGuild(int gameid,
|
|
long long guild_id,
|
|
const std::string& guild_name,
|
|
int guild_lv,
|
|
int guild_exp,
|
|
int guild_badge,
|
|
int guild_apply_num,
|
|
const std::string& guild_members,
|
|
const std::string& guild_notice,
|
|
const std::string& guild_declaration,
|
|
const std::string& guild_log,
|
|
const std::string& owner_id,
|
|
const std::string& owner_name,
|
|
const std::string& owner_avatar_url,
|
|
const std::string& creator_id,
|
|
const std::string& creator_name,
|
|
const std::string& creator_avatar_url,
|
|
const std::string& guild_data,
|
|
int guild_status,
|
|
int createtime
|
|
)
|
|
{
|
|
if (GetGuild(guild_id)) {
|
|
abort();
|
|
}
|
|
Guild* guild = new Guild;
|
|
guild->gameid = gameid;
|
|
guild->guild_id = guild_id;
|
|
guild->guild_name = guild_name;
|
|
guild->guild_lv = guild_lv;
|
|
guild->guild_exp = guild_exp;
|
|
guild->guild_badge = guild_badge;
|
|
guild->guild_apply_num = guild_apply_num;
|
|
guild->guild_notice = guild_notice;
|
|
guild->guild_declaration = guild_declaration;
|
|
guild->owner_id = owner_id;
|
|
guild->owner_name = owner_name;
|
|
guild->owner_avatar_url = owner_avatar_url;
|
|
guild->creator_id = creator_id;
|
|
guild->creator_name = creator_name;
|
|
guild->creator_avatar_url = creator_avatar_url;
|
|
guild->guild_status = guild_status;
|
|
guild->createtime = createtime;
|
|
//guild_members
|
|
guild->Deserialize(guild_data, guild_log);
|
|
id_hash_[guild_id] = guild;
|
|
}
|