def patch(self, message, union_message, data, now):
"""填充联盟战争信息
Args:
message[protobuf UnionBattleInfo]: 需要打包的联盟信息
union_message[protobuf UnionBattleInfo]: 己方联盟返回的战斗信息
data[UserData]
now[int]: 时间戳
"""
#本方联盟返回的联盟战斗信息
message.CopyFrom(union_message)
#补充个人信息
user = data.user.get(True)
union = data.union.get(True)
message.user.user.user_id = user.id
message.user.user.name = user.get_readable_name()
message.user.user.headicon_id = user.icon_id
message.user.left_attack_count = union.battle_attack_count_left
message.user.refresh_attack_num = union.battle_attack_refresh_num
message.user.drum_count = union.battle_drum_count
if (union_message.stage != union_message.INVALID
and union_message.stage != union_message.IDLE):
#在战争中，需要查询对手联盟的战斗信息
rival_union_req = internal_union_pb2.InternalQueryUnionBattleReq()
defer = GlobalObject().remote['gunion'].callRemote(
"query_battle", union_message.rival_union_id,
rival_union_req.SerializeToString())
defer.addCallback(self._patch_rival_battle_info, message, data,
now)
return defer
else:
return self._patch_ranking_info(message, data, now)
def enterInstance1(dynamicId, characterId, InstanceId):
'''进入副本
@param dynamicId: int 角色动态id
@param characterId: int 角色id
@param InstanceId: int 副本id
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer or vplayer.getLocked(): #判断是否存在角色或者角色是否被锁定
return
oldnode = 201000
if oldnode < 300000 and oldnode != 0: #如果角色在场景
#创建新的副本返回服务器编号，副本动态id
famserTag, famId = FamSerManager().createNewFam(dynamicId)
if famserTag < 0:
return
vplayer.lock() #锁定角色对象
newnode = 300000 + famserTag
#获取角色在原先场景中的实例
d = GlobalObject().root.callChild("scense_1000", 610, dynamicId,
characterId)
#调用失败后的处理
d.addErrback(InFamErrbck, vplayer, newnode, famId)
#进入副本
d.addCallback(Transfer1501, newnode, dynamicId, characterId,
InstanceId, famId)
return d
else:
dd = defer.Deferred()
dd.callback({'result': True, 'message': u'nofam'})
return dd
def enterInstance1(dynamicId, characterId, InstanceId):
'''进入副本
@param dynamicId: int 角色动态id
@param characterId: int 角色id
@param InstanceId: int 副本id
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer or vplayer.getLocked():#判断是否存在角色或者角色是否被锁定
return
oldnode = 201000
if oldnode < 300000 and oldnode != 0:#如果角色在场景
#创建新的副本返回服务器编号，副本动态id
famserTag,famId=FamSerManager().createNewFam(dynamicId)
if famserTag <0:
return
vplayer.lock()#锁定角色对象
newnode = 300000+famserTag
#获取角色在原先场景中的实例
d = GlobalObject().root.callChild("scense_1000",610,dynamicId, characterId)
#调用失败后的处理
d.addErrback(InFamErrbck,vplayer,newnode,famId)
#进入副本
d.addCallback(Transfer1501,newnode,dynamicId,characterId,InstanceId,famId)
return d
else:
dd = defer.Deferred()
dd.callback({'result':True,'message':u'nofam'})
return dd
def _calc_try_forward_season_result(self, union_response, expect,
union_ids, req, res, timer):
union_res = union_battle_pb2.TryForwardUnionBattleSeasonRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Try forward union battle season res error")
if expect is None and not union_res.enable:
#无法进入下一个赛季，直接返回
return self._try_forward_season_succeed(req, res, timer)
elif expect is not None and union_res.enable != expect:
#各个联盟进入下一个赛季，出现不一致的情况
logger.warning("Try forward union battle season unexpected")
#各个联盟均已经进入下一个赛季
if len(union_ids) == 0:
res.enable = True
self._try_forward_season_for_user_not_belong_to_union()
return self._try_forward_season_succeed(req, res, timer)
union_id = union_ids.pop()
union_req = union_battle_pb2.TryForwardUnionBattleSeasonReq()
defer = GlobalObject().remote['gunion'].callRemote(
"try_forward_season", union_id, union_req.SerializeToString())
defer.addCallback(self._calc_try_forward_season_result, True,
union_ids, req, res, timer)
return defer
def _calc_exchange(self, data, req, timer):
comm_req = exchange_pb2.QueryExchangeProportionReq()
comm_req.user_id = data.id
defer = GlobalObject().remote["common"].callRemote(
"query_exchange_info", 1, comm_req.SerializeToString())
defer.addCallback(self._calc_exchange_proportion, data, req, timer)
return defer
def _calc_update(self, data, req, timer):
"""更新史实城信息
请求 unit 模块
"""
city_id = LegendCityInfo.generate_id(data.id, req.city_id)
legendcity = data.legendcity_list.get(city_id)
unit_req = unit_pb2.UnitUpdateLegendCityReq()
unit_req.user_id = data.id
if req.HasField("slogan"):
unit_req.slogan = req.slogan
if req.HasField("tax"):
unit_req.tax = req.tax
if req.HasField("gold"):
#消耗元宝
unit_req.gold = req.gold
resource = data.resource.get()
original_gold = resource.gold
if not resource.cost_gold(req.gold):
raise Exception("Cost gold failed")
log = log_formater.output_gold(data,
-req.gold,
log_formater.LEGENDCITY_UPDATE,
"Updata legendcity",
before_gold=original_gold)
logger.notice(log)
defer = GlobalObject().remote['unit'].callRemote(
"update_city_info", legendcity.city_id,
unit_req.SerializeToString())
defer.addCallback(self._check_update, data, req, timer)
defer.addCallback(self._update_succeed, data, req, timer)
return defer
def _try_forward_season_for_user_not_belong_to_union(self):
"""让不属于任何联盟的玩家，且参加过上个赛季联盟战争的玩家，进入下一个赛季
"""
users = []
flag = True
begin = 0
gap = 50
while flag:
proxy = DataProxy()
proxy.search_by_rank("union", "season_score", begin, begin + gap)
defer = proxy.execute()
for i, indiv_info in enumerate(
proxy.get_rank_result("union", "season_score", begin,
begin + gap)):
if indiv_info.season_score > 0:
if indiv_info.user_id not in users:
users.append(indiv_info.user_id)
else:
flag = False
break
begin += gap
for user_id in users:
req = internal_pb2.UnionBattleForwardReq()
defer = GlobalObject().root.callChild(
"portal", "forward_union_battle_season_forward", user_id,
req.SerializeToString())
defer.addCallback(
self._check_forward_season_for_user_not_belong_to_union)
def _calc_finish_battle(self, data, req, timer):
res = transfer_arena_pb2.FinishTransferArenaBattleRes()
res.status = 0
#记录次数
trainer = data.trainer.get()
trainer.add_daily_battle_transfer(1)
transfer = data.transfer.get()
if req.target_id not in transfer.get_match_ids():
res.ret = transfer_arena_pb2.FinishTransferArenaBattleRes.TARGET_ERROR
return self._finish_battle_succeed(data, req, res, timer)
transfer.finish_battle(timer.now)
win = True if req.battle.result == battle_pb2.BattleOutputInfo.WIN else False
#请求common模块进行换位
common_req = internal_pb2.InternalExchangeTransferReq()
common_req.user_id = data.id
common_req.target_user_id = req.target_id
common_req.exchange = win
common_request = common_req.SerializeToString()
defer = GlobalObject().remote["common"].callRemote(
"exchange_transfer", 1, common_request)
defer.addCallback(self._calc_finish_battle_result, data, req, timer)
return defer
def _delete_player(self, data, req, timer):
if not data.is_valid():
return data
force = False
if req.HasField("force") and req.force == True:
force = True
#删除用户数据:
# 1. 删除联盟数据
# 2. 删除史实城官职信息
# 3. 删除用户数据
union = data.union.get(True)
if union is not None and force:
# 退出联盟
union_req = internal_union_pb2.InternalManageUnionReq()
union_req.user_id = data.id
union_req.op = union_pb2.ManageUnionReq.EXIT
union_req.target_user_id = data.id
defer = GlobalObject().remote['gunion'].callRemote(
"manage_union", union.union_id, union_req.SerializeToString())
defer.addCallback(self._delete_player_union, data)
return defer
return self._delete_player_union(None, data)
def _kickout(self, data, member, target_user_id, timer):
"""踢人
"""
target_member = member_business.find_member(data, target_user_id)
if target_member is None:
logger.debug("User is not belong to union")
return self._pack_manage_response(union_pb2.UNION_MEMBER_INVALID)
if member.user_id == target_user_id:
#任何人都不能踢自己
logger.debug("User is not belong to union")
return self._pack_manage_response(union_pb2.UNION_NO_AUTH)
elif member.is_normal_member():
#成员不能踢人
return self._pack_manage_response(union_pb2.UNION_NO_AUTH)
elif member.is_vice_leader() and not target_member.is_normal_member():
#副盟主只可以踢成员
return self._pack_manage_response(union_pb2.UNION_NO_AUTH)
union = data.union.get()
member_business.leave_union(data, target_member)
app_req = internal_union_pb2.InternalUnionOperateReq()
app_req.operator_user_id = member.user_id
app_req.union_name = union.get_readable_name()
app_req.union_id = union.id
defer = GlobalObject().remote['app'].callRemote(
"been_kickout_from_union", target_user_id,
app_req.SerializeToString())
defer.addCallback(self._post_kickout, data, timer)
return defer
def _calc_create_result(self, union_response, data, req, timer):
union_res = internal_union_pb2.InternalQueryUnionRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Create union res error")
res = union_pb2.CreateUnionRes()
res.status = 0
res.ret = union_res.ret
if res.ret != union_pb2.UNION_OK:
return self._create_succeed(data, req, res, timer)
#创建联盟
union_business.create_union(
data, union_res.union.id, req.gold_cost, timer.now)
res.union.CopyFrom(union_res.union)
#第一次创建联盟返回时要把union member信息不全
user = data.user.get(True)
res.union.members[0].user.name = user.get_readable_name()
res.union.members[0].user.level = user.level
res.union.members[0].user.headicon_id = user.icon_id
#查询联盟boss
union_req = internal_union_pb2.InternalQueryUnionBossReq()
union_req.user_id = data.id
union = data.union.get(True)
defer = GlobalObject().remote['gunion'].callRemote(
"query_unionboss", union.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_create_result_unionboss, data, req, res, timer)
return defer
def _calc_buy_legendcity_goods(self, data, req, timer):
"""购买史实城商店中的商品
"""
shop_id = ShopInfo.generate_id(data.id, ShopInfo.GOODS_TYPE_LEGENDCITY,
req.index)
shop = data.shop_list.get(shop_id)
pay = shop.calc_goods_price(req.goods.id)
extra_pay = int(pay * (req.tax / 100.0))
if not shop_business.buy_goods(data, shop, req.goods.id, timer.now,
req.tax):
raise Exception("Buy Goods failed")
compare.check_item(data, req.item)
#请求 Unit 模块，缴税
unit_req = unit_pb2.UnitBuyGoodsReq()
unit_req.user_id = data.id
unit_req.pay = pay
unit_req.extra_pay = extra_pay
unit_req.tax = req.tax
defer = GlobalObject().remote['unit'].callRemote(
"buy_goods", req.index, unit_req.SerializeToString())
defer.addCallback(self._pack_buy_legendcity_goods_response, data, req,
timer)
return defer
def _calc_delete_legend_city(self, status, city_id, timer):
assert status == 0
unit_req = unit_pb2.UnitDeleteLegendCityReq()
defer = GlobalObject().remote['unit'].callRemote(
"delete_city", city_id, unit_req.SerializeToString())
defer.addCallback(self._check_delete_legend_city, city_id, timer)
return defer
def _calc_get_position_rank(self, state, city_id, res, timer):
assert state == True
unit_req = unit_pb2.UnitGetPositionRankReq()
defer = GlobalObject().remote['unit'].callRemote(
"get_position_rank", city_id, unit_req.SerializeToString())
defer.addCallback(self._check_position_rank, city_id, res, timer)
return defer
def _get_members_info(members, members_info, i):
app_req = internal_pb2.GetUserBasicInfoReq()
app_req.user_id = members[i].user_id
defer = GlobalObject().remote['app'].callRemote("get_user_basic_info",
members[i].user_id, app_req.SerializeToString())
defer.addCallback(_get_members_info_result, members, members_info, i)
return defer
def _forward_award_prosperity(self, union_id, prosperity):
union_req = internal_union_pb2.InternalAddUnionProsperityReq()
union_req.prosperity = prosperity
defer = GlobalObject().remote['gunion'].callRemote(
"add_prosperity", union_id, union_req.SerializeToString())
defer.addCallback(self._check_award_prosperity)
return defer
def _query_notice(self, data, basic_data, request, req, timer):
#查询广播信息
defer = GlobalObject().remote["common"].callRemote(
"query_broadcast_record", 1, request)
defer.addCallback(self._check_query_broadcast_record_result,
basic_data, data, req, timer)
return defer
def _calc_delete_common(self, status, common_id, timer):
assert status == 0
req = internal_pb2.DeleteCommonReq()
defer = GlobalObject().remote['common'].callRemote(
"delete_common", common_id, req.SerializeToString())
defer.addCallback(self._check_delete_common, common_id, timer)
return defer
def _calc_union_chat(self, data, req, timer):
#assert req.type == req.UNION
union_req = internal_union_pb2.InternalStartUnionChatReq()
union_req.user_id = data.id
defer = GlobalObject().remote['gunion'].callRemote(
"start_union_chat", req.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_union_chat_result, req, timer)
return defer
def _calc_query_anneal_record(self, data, request, req, timer):
"""
"""
#查询通关信息
defer = GlobalObject().remote["common"].callRemote(
"query_anneal_record", 1, request)
defer.addCallback(self._check_query_anneal_record_result, data, req,
timer)
return defer
def _calc_delete_notice(self, data, request, req, timer):
"""
"""
#删除广播信息
defer = GlobalObject().remote["common"].callRemote(
"delete_broadcast_record", 1, request)
defer.addCallback(self._check_delete_broadcast_record_result, data,
req, timer)
return defer
def _query_union_info(self, proxy, data, plunder, rival, req, timer):
""""""
union_req = internal_union_pb2.InternalQueryUnionReq()
union_req.user_id = data.id
defer = GlobalObject().remote['gunion'].callRemote(
"query_union_summary", rival.union_id, union_req.SerializeToString())
defer.addCallback(self._pack_query_player_response, data, plunder, rival, req, timer)
return defer
def _calc_gain(self, data, req, timer):
union = data.union.get()
union_req = internal_union_pb2.InternalGainUnionBattleScoreReq()
union_req.union_score = req.score
defer = GlobalObject().remote['gunion'].callRemote(
"gain_battle_score", req.union_id, union_req.SerializeToString())
defer.addCallback(self._calc_gain_post, data, req, timer)
return defer
def _calc_query_transfer_arena(self, data, req, timer):
req = internal_pb2.InternalQueryTransferReq()
req.user_id = data.id
request = req.SerializeToString()
defer = GlobalObject().remote["common"].callRemote(
"query_transfer_info", 1, request)
defer.addCallback(self._calc_query_transfer_arena_result, data, req,
timer)
return defer
def _forward_award_honor(self, user_id, union_id, honor):
forward_req = union_pb2.AddUnionHonorReq()
forward_req.union_id = union_id
forward_req.honor = honor
defer = GlobalObject().root.callChild("portal", "forward_add_honor",
user_id,
forward_req.SerializeToString())
defer.addCallback(self._check_award_honor)
return defer
def _calc_send_mail_to_all_members(member_list, i, user_id, mail_message):
app_req = internal_pb2.AddMailReq()
app_req.user_id = user_id
app_req.recipients_user_id = member_list[i].user_id
app_req.mail.CopyFrom(mail_message)
defer = GlobalObject().remote['app'].callRemote("add_mail",
user_id, app_req.SerializeToString())
defer.addCallback(_calc_send_mail_to_all_members_result, member_list, i, user_id, mail_message)
return defer
def _calc_delete(self, status, union_id, timer):
"""删除联盟
"""
#请求 Union 模块，删除联盟
union_req = internal_union_pb2.InternalDeleteUnionReq()
defer = GlobalObject().remote['gunion'].callRemote(
"delete_union", union_id, union_req.SerializeToString())
defer.addCallback(self._check_delete_result, union_id, timer)
return defer
def _sync_union(self, data, union_id, timer):
"""同步联盟信息
"""
#请求 Union 模块
union_req = internal_union_pb2.InternalQueryUnionReq()
union_req.user_id = data.id
defer = GlobalObject().remote['gunion'].callRemote(
"sync_union", union_id, union_req.SerializeToString())
defer.addCallback(self._calc_sync_result, data, timer)
return defer
def JoinDuiWu(dynamicId, pid, pos, dwId):
"""加入队伍
"""
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer or vplayer.getLocked(): # 判断是否存在角色或者角色是否被锁定
return
# nownode = vplayer.getNode()
d = GlobalObject().root.callChild("scense_1000", 610, dynamicId, pid)
d.addErrback(ErorrBack)
d.addCallback(TransferPlayerJoin, dynamicId, pid, pos, dwId)
return d
def _try_cancel_position_of_legendcity(self, data, city_id_list):
"""试图撤掉所有史诗城的官职"""
unit_req = unit_pb2.UnitCancelPositionReq()
unit_req.user_id = data.id
unit_req.force = True
city_id = city_id_list[-1]
defer = GlobalObject().remote['unit'].callRemote(
"cancel_position", city_id, unit_req.SerializeToString())
defer.addCallback(self._recv_cancel_position_of_legendcity, data,
city_id_list)
return defer
def _forward_clear_worldboss_merit(self, user_id, timer):
"""向用户转发清空世界boss战功的请求
"""
req = boss_pb2.ReceiveClearWorldBossMeritReq()
request = req.SerializeToString()
defer = GlobalObject().root.callChild("portal",
"forward_clear_worldboss_merit",
user_id, request)
defer.addCallback(self._check_forward_clear_worldboss_merit)
return defer
def CreateZuDui(dynamicId,pid,pos,gkType):
'''创建队伍
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer or vplayer.getLocked():#判断是否存在角色或者角色是否被锁定
return
# nownode = vplayer.getNode()
d = GlobalObject().root.callChild("scense_1000",610,dynamicId, pid)
d.addErrback(ErorrBack)
d.addCallback(TransferPlayerCreate,dynamicId,pid,pos,gkType)
return d
def TransferPlayer(deferData,nownode,dynamicId,characterId,placeId,force,vplayer):
'''传递角色'''
player,oldplaceId = deferData
#将角色信息写入新的场景
d=GlobalObject().root.callChild("scense_1000",612,601,dynamicId, characterId, placeId,force,player)
# d = root.callChild(nownode,601,dynamicId, characterId, placeId,force,player)
#调用失败后的处理
d.addErrback(sceneErorrBack,vplayer)
#删除原先场景中的角色
d.addCallback(DropCharacterInScene,vplayer,nownode,dynamicId)
return d
def Transfer1501(resultdata,nownode,dynamicId,characterId,instanceId,famId):
'''调用进入副本方法
@param nownode: int 副本服务器动态id+30W
'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
player,placeId = resultdata
#加入角色的实例到创建的副本中去
d = GlobalObject().root.callChild("scense_1000",1501,player,dynamicId,characterId,instanceId,famId)
#写入出错时的错误处理
d.addErrback(InFamErrbck,vplayer,nownode,famId)
#写入成功时,清除原先场景中的角色实例
d.addCallback(DropCharacterInSceneForFam,vplayer,nownode,dynamicId,famId)
return d
def DropCharacterInScene(deferResult,vcharacter,nownode,dynamicId):
'''删除原先场景中角色的实例
'''
if not deferResult.get('result',False):#如果不能进行跳转
vcharacter.release()#释放角色对象锁
d = defer.Deferred()
d.callback(deferResult)
else:
# oldnode = vcharacter.getNode()
d=GlobalObject().root.callChild("scense_1000",612,dynamicId, vcharacter.characterId)
# d = root.callChild(oldnode,612,dynamicId, vcharacter.characterId)
d.addErrback(sceneErorrBack2,nownode,dynamicId,vcharacter)
d.addCallback(cleanOldScene,deferResult,vcharacter,dynamicId,nownode)
return d
def DropCharacterInSceneForFam(deferResult,vcharacter,nownode,dynamicId,famId):
'''删除原先场景角色的实例
'''
if not deferResult.get('result',False):#如果不能进行跳转
vcharacter.release()#释放角色对象锁
d = defer.Deferred()
d.callback(deferResult)
else:
# oldnode = vcharacter.getNode()
#通知原先场景服务器删除角色的信息
d = GlobalObject().root.callChild("scense_1000",612,dynamicId, vcharacter.characterId)
#消息出错时的处理
d.addErrback(InFamErrbck2,vcharacter,nownode,famId)
#消息成功时的处理
d.addCallback(cleanOldSceneForFam,deferResult,vcharacter,nownode,famId)
return d
def Transfer1502(data,dynamicId,characterId,force):
'''离开副本后将角色实例传递回来
'''
player, placeId = data
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
oldnode = 201000 #vplayer.getNode()
famId = vplayer.getFamId()
if oldnode < 300000:
dp = defer.Deferred()
dp.callback({'result':True,'message':u'nofam'})
return dp
nownode = SceneSerManager().getBsetScenNodeId(placeId)
d = GlobalObject().root.callChild("scense_1000",601,dynamicId, characterId, placeId,force,player)
#进入场景错误时的处理
d.addErrback(sceneErorrBack,vplayer)
#进入成功时
d.addCallback(DropCharacterInFam,vplayer,nownode,dynamicId,oldnode,famId)
return d
def closeInstance(dynamicId,characterId):
'''退出副本'''
vplayer = VCharacterManager().getVCharacterByClientId(dynamicId)
if not vplayer:
dp = defer.Deferred()
dp.callback({'result':True,'message':u'nofam'})
return dp
oldnode = 201000 #vplayer.getNode()
if oldnode > 300000:#如果角色在副本中
#锁定角色对象
vplayer.lock()
#获取角色在原先场景中的实例
d = GlobalObject().root.callChild("scense_1000",610,dynamicId, characterId)
#获取错误时的处理
d.addErrback(sceneErorrBack,vplayer)
#获取成功时的处理
d.addCallback(Transfer1502,dynamicId,characterId,True)
return d
else:
dp = defer.Deferred()
dp.callback({'result':True,'message':u'nofam'})
return dp
