def _calc_receive(self, data, req, timer):
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
#添加对战记录
transfer_business.add_battle_record(
data, req.rival_user_id, req.rival_user_name, req.rival_level,
req.rival_icon, TransferRecordInfo.DEFEND_WIN if req.win else
TransferRecordInfo.DEFEND_LOSE, req.self_rank, req.rival_rank)
#向用户推送
transfer = data.transfer.get(True)
transfer_records = data.transfer_record_list.get_all(True)
push_res = transfer_arena_pb2.QueryTransferArenaRes()
push_res.status = 0
push_res.arena_info.remain_times = transfer.get_remain_times()
push_res.arena_info.cd_end_time = transfer.get_cd_end_time(timer.now)
for transfer_record in transfer_records:
pack.pack_transfer_record(transfer_record,
push_res.arena_info.records.add())
push_response = push_res.SerializeToString()
GlobalObject().root.callChild("portal", "push_transfer_record",
data.id, push_response)
res = internal_pb2.InternalTransferNoticeRes()
res.status = 0
defer = DataBase().commit(data)
defer.addCallback(self._receive_succeed, req, res, timer)
return defer
def _calc_refresh(self, data, req, timer):
res = internal_union_pb2.InternalRefreshBoxRes()
res.status = 0
if not data.is_valid():
res.ret = union_pb2.UNION_NOT_MATCHED
return self._refresh_succeed(data, req, res, timer)
member = member_business.find_member(data, req.user_id)
if member is None:
res.ret = union_pb2.UNION_NOT_MATCHED
return self._refresh_succeed(data, req, res, timer)
ret = donate_business.is_able_to_refresh_donate_box(
data, req.box_id, req.user_id, timer)
if ret != 0:
res.ret = ret
else:
new_donate_box = donate_business.refresh_donate_box(
data, req.box_id, timer)
res.ret = union_pb2.UNION_OK
pack.pack_donate_box_info(data, req.user_id, new_donate_box,
res.box_info, timer)
defer = DataBase().commit(data)
defer.addCallback(self._refresh_succeed, req, res, timer)
return defer
def _calc_buy_goods(self, data, req, timer):
union = data.union.get()
if not union.is_belong_to_target_union(req.index):
#玩家不属于联盟
logger.debug("User is not belong to union")
res = wineShop_pb2.BuyGoodsRes()
res.status = 0
res.invalid = True
else:
shop_id = ShopInfo.generate_id(data.id, req.goods.type)
shop = data.shop_list.get(shop_id)
if not shop_business.buy_goods(data, shop, req.goods.id,
timer.now):
raise Exception("Buy Goods failed")
compare.check_item(data, req.item)
res = wineShop_pb2.BuyGoodsRes()
res.status = 0
pack.pack_resource_info(data.resource.get(True), res.resource)
res.current_tokens = union.honor
defer = DataBase().commit(data)
defer.addCallback(self._buy_goods_succeed, req, res, timer)
return defer
def _calc_query(self, data, req, timer, force):
union = data.union.get(True)
if not force and not union.is_belong_to_target_union(req.union_id):
#已经不属于对应联盟
res = union_pb2.QueryUnionRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
res.monarch.user_id = data.id
res.monarch.union_id = union.union_id
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
union.update_daily_info(timer.now)
union_req = internal_union_pb2.InternalQueryUnionReq()
union_req.user_id = data.id
#请求 Union 模块，查询联盟情况
if not force:
defer = GlobalObject().remote['gunion'].callRemote(
"query_union", union.union_id, union_req.SerializeToString())
else:
defer = GlobalObject().remote['gunion'].callRemote(
"query_union_force", req.union_id, union_req.SerializeToString())
defer.addCallback(self._update_query_info, data, req, timer)
return defer
def _calc_buy_energy(self, data, req, timer):
"""
"""
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
energy = data.energy.get()
energy.update_current_energy(timer.now)
need_gold, original_gold = energy_business.buy_energy(
data, energy, timer.now)
if need_gold < 0:
raise Exception("Buy energy failed")
#记录次数
trainer = data.trainer.get()
trainer.add_daily_buy_energy_num(1)
log = log_formater.output_gold(data,
-need_gold,
log_formater.BUY_ENERGY,
"Buy energy by gold",
before_gold=original_gold,
energy=energy.get_energy_num_of_buy())
logger.notice(log)
return DataBase().commit(data)
def _calc_reset(self, data, req, timer):
res = dungeon_pb2.QueryExpandDungeonInfoRes()
res.status = 0
dungeon = expand_dungeon_business.get_dungeon_by_id(data, req.id)
if dungeon is None:
res.ret = dungeon_pb2.DUNGEON_NO_DUNGEON
return self._reset_succeed(data, req, res, timer)
ret = expand_dungeon_business.reset_attack_count(
data, dungeon, timer.now)
if ret != dungeon_pb2.DUNGEON_OK:
res.ret = ret
return self._reset_succeed(data, req, res, timer)
resource = data.resource.get()
resource.update_current_resource(timer.now)
user = data.user.get(True)
res.ret = dungeon_pb2.DUNGEON_OK
pack.pack_expand_dungeon_info(dungeon,
user,
res.dungeon_info,
0,
timer.now,
brief=True)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._reset_succeed, req, res, timer)
return defer
def _calc_search(self, data, req, timer):
union = data.union.get(True)
user = data.user.get(True)
if union.is_locked(timer.now):
logger.debug("Union is locked")
res = union_pb2.SearchUnionRes()
res.status = 0
res.lock_left_time = union.lock_time - timer.now
defer = DataBase().commit(data)
defer.addCallback(self._search_succeed, req, res, timer)
return defer
else:
if req.type == req.SEARCH:
matcher = UnionMatcher()
matcher.add_condition(req.union_id, req.name)
defer = matcher.match()
elif req.type == req.RECOMMEND:
matcher = UnionRecommender()
matcher.add_condition(user)
defer = matcher.match(timer.now)
elif req.type == req.RANK:
matcher = UnionRanker()
defer = matcher.match(timer.now)
defer.addCallback(self._calc_search_result, data, req, timer)
return defer
def _calc_respond(self, data, req, timer):
"""援助
"""
if not data.is_valid():
#联盟不存在
res = self._pack_respond_response_invalid(union_pb2.UNION_NOT_MATCHED)
return self._respond_succeed(data, req, res, timer)
member = member_business.find_member(data, req.user_id)
target_member = member_business.find_member(data, req.target_user_id)
if member is None:
res = self._pack_respond_response_invalid(union_pb2.UNION_MEMBER_INVALID)
elif target_member is None:
res = self._pack_respond_response_invalid(union_pb2.UNION_AID_INVALID)
else:
aid = aid_business.respond_aid(
data, member, target_member, req.item_basic_id, timer.now)
if aid is None:
res = self._pack_respond_response_invalid(union_pb2.UNION_AID_INVALID)
else:
res = self._pack_respond_response(aid, req.user_id)
defer = DataBase().commit(data)
defer.addCallback(self._respond_succeed, req, res, timer)
return defer
def _calc_query_anneal_record(self, data, req, timer):
"""查询逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
record = anneal_record_business.query_anneal_record(data, req.floor)
res = anneal_pb2.QueryAnnealRecordRes()
res.status = 0
record_message = res.records.add()
record_message.type = 1
record_message.name = record.get_readable_first_name()
record_message.level = record.first_level
record_message.icon_id = record.first_icon_id
record_message.finish_passed_time = timer.now - record.first_finished_time
record_message = res.records.add()
record_message.type = 2
record_message.name = record.get_readable_fast_name()
record_message.level = record.fast_level
record_message.icon_id = record.fast_icon_id
record_message.finish_passed_time = timer.now - record.fast_finished_time
record_message.cost_time = record.fast_cost_time
defer = DataBase().commit(data)
defer.addCallback(self._query_anneal_record_succeed, req, res, timer)
return defer
def _calc_cancel_position(self, data, req, timer):
#如果史实城数据不存在，初始化（lazy，第一次访问时初始化）
if not data.is_valid():
if not city_business.init_city(data, timer.now):
raise Exception("Init city failed")
#如果玩家被锁定，无法取消官职
position_id = UnitPositionInfo.generate_id(data.id, req.user_id)
user_position = data.position_list.get(position_id)
if user_position is not None:
user_position.check_lock_status(timer.now)
if user_position.is_locked and req.force == False:
logger.debug("User is locked[user_id=%d]" % req.user_id)
res = self._pack_cancel_position_response(
legendcity_pb2.USER_LOCKED,
user_position.get_unlock_time(timer.now))
else:
city_business.cancel_position(data, user_position, timer.now)
res = self._pack_cancel_position_response(legendcity_pb2.OK)
else:
res = self._pack_cancel_position_response(legendcity_pb2.OK)
defer = DataBase().commit(data)
defer.addCallback(self._cancel_position_succeed, req, res, timer)
return defer
def _calc_query(self, data, req, timer):
"""查询逻辑
"""
#如果史实城数据不存在，初始化（lazy，第一次访问时初始化）
if not data.is_valid():
if not city_business.init_city(data, timer.now):
raise Exception("Init city failed")
city_business.try_calc_today_tax_income(data, timer.now)
rivals_info = []
for index in range(0, len(req.rivals_id)):
rivals_info.append((req.rivals_id[index], req.rivals_position_level[index]))
#查询玩家自己的官职信息
valid = True
rematch_position_level = req.rematch_position_level
user_position = city_business.query_user_position(data, req.user_id, timer.now)
if rematch_position_level != 0 and user_position.level + 1 != rematch_position_level:
logger.warning("Not able to rematch[user level=%d][rematch level=%d]" %
(user_position.level, req.rematch_position_level))
valid = False
rematch_position_level = 0
(invalid_rivals, new_rivals) = city_business.query_position(
data, req.user_id, user_position.level,
rivals_info, timer.now, rematch_position_level)
res = self._pack_query_response(data, user_position, invalid_rivals, new_rivals, valid)
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
def _calc_check(self, data, req, timer):
"""核实信息
1 检查对手官职，有没有发生变化
2 检查玩家官职，可以向对手发起攻击
3 检查双方是否被锁定
"""
id = UnitPositionInfo.generate_id(data.id, req.user_id)
user_position = data.position_list.get(id, True)
id = UnitPositionInfo.generate_id(data.id, req.rival_id)
rival_position = data.position_list.get(id, True)
user_position.check_lock_status(timer.now)
rival_position.check_lock_status(timer.now)
if rival_position.level != req.rival_position_level:
res = self._pack_check_response(legendcity_pb2.RIVAL_INVALID)
elif user_position.level + 1 != rival_position.level and not rival_position.is_leader():
#对手不是太守，玩家官职不比对手低一级
res = self._pack_check_response(legendcity_pb2.USER_INVALID)
elif user_position.is_locked:
res = self._pack_check_response(
legendcity_pb2.USER_LOCKED, user_position.get_unlock_time(timer.now))
elif rival_position.is_locked:
res = self._pack_check_response(
legendcity_pb2.RIVAL_LOCKED, rival_position.get_unlock_time(timer.now))
else:
res = self._pack_check_response(legendcity_pb2.OK)
defer = DataBase().commit(data)
defer.addCallback(self._check_succeed, req, res, timer)
return defer
def _calc_reset_hard_attack_num(self, data, req, timer):
res = anneal_pb2.ResetHardAttackNumRes()
res.status = 0
ret = Ret()
if not anneal_business.reset_hard_attack_num(data, req.floor,
timer.now, ret):
if ret.get() == 'GOLD_NOT_ENOUGH':
res.ret = anneal_pb2.ResetHardAttackNumRes.GOLD_NOT_ENOUGH
elif ret.get() == 'VIP_NOT_ENOUGH':
res.ret = anneal_pb2.ResetHardAttackNumRes.VIP_NOT_ENOUGH
return self._reset_hard_attack_num_succeed(data, req, res, timer)
resource = data.resource.get()
resource.update_current_resource(timer.now)
res.ret = anneal_pb2.ResetHardAttackNumRes.OK
pack.pack_resource_info(resource, res.resource)
pack.pack_anneal_info(data, data.anneal.get(True), res.anneal,
timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._reset_hard_attack_num_succeed, req, res, timer)
return defer
def _calc_buy(self, data, req, timer):
res = transfer_arena_pb2.BuyChallengeTimesRes()
res.status = 0
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
ret = Ret()
if not transfer_business.buy_attack_times(data, timer.now, ret):
if ret.get() == "NO_ENOUGH_GOLD":
res.ret = transfer_arena_pb2.BuyChallengeTimesRes.NO_ENOUGH_GOLD
return self._buy_succeed(data, req, res, timer)
elif ret.get() == "UPPER_LIMIT":
res.ret = transfer_arena_pb2.BuyChallengeTimesRes.UPPER_LIMIT
return self._buy_succeed(data, req, res, timer)
transfer = data.transfer.get()
transfer_records = data.transfer_record_list.get_all(True)
res.ret = transfer_arena_pb2.BuyChallengeTimesRes.OK
res.arena_info.remain_times = transfer.get_remain_times()
res.arena_info.cd_end_time = transfer.get_cd_end_time(timer.now)
for transfer_record in transfer_records:
pack.pack_transfer_record(transfer_record,
res.arena_info.records.add())
resource = data.resource.get(True)
pack.pack_resource_info(resource, res.resource)
defer = DataBase().commit(data)
defer.addCallback(self._buy_succeed, req, res, timer)
return defer
def _calc_modify(self, data, req, timer):
"""修改逻辑
"""
if not data.is_valid():
if not console_business.init_console(data, timer.now):
raise Exception("Init console failed")
worldboss = data.worldboss.get()
if req.HasField("total_soldier_num"):
worldboss.total_soldier_num = req.total_soldier_num
if req.HasField("current_soldier_num"):
worldboss.current_soldier_num = req.current_soldier_num
if req.HasField("kill_user_name"):
worldboss.kill_user_name = req.kill_user_name
if req.HasField("kill_user_id"):
worldboss.kill_user_id = req.kill_user_id
res = boss_pb2.ModifyWorldBossRes()
res.status = 0
defer = DataBase().commit(data)
defer.addCallback(self._modify_succeed, req, res, timer)
return defer
def _calc_treasure_draw(self, data, basic_data, req, type,timer):
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
user = data.user.get()
resource = data.resource.get()
draw = data.draw.get()
resource.update_current_resource(timer.now)
item_list = []
if not draw_business.treasure_draw(
basic_data, data, user, resource, draw,
item_list, req, timer.now):
raise Exception("Treasure draw failed")
#添加抽奖得到的英雄和物品
if not item_business.gain_item(data, item_list, "trun draw ", log_formater.DRAW):
raise Exception("Gain item failed")
alltimes = draw.total_treasure_draw_num
res = self._pack_treasure_draw_response(data, item_list, resource, alltimes, timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._draw_treasure_succeed, type, req, res, timer)
return defer
def _calc_upgrade(self, data, req, timer):
"""进行升级
"""
#涉及到跨天的数据统计，所以此处要更新所有跨天数据
if not account_business.update_across_day_info(data, timer.now):
raise Exception("Update across day info failed")
node_basic_id = req.node.basic_id
node_id = NodeInfo.generate_id(data.id, node_basic_id)
node = data.node_list.get(node_id)
gold = 0
if req.HasField("gold"):
gold = req.gold
if not exploitation_business.finish_upgrade_event(
data, node, timer.now, gold):
raise Exception("Finish upgrade event failed")
resource = data.resource.get(True)
res = self._pack_upgrade_response(data, resource, node, timer.now)
map_business.check_map_data(data)
defer = DataBase().commit(data)
defer.addCallback(self._upgrade_succeed, req, res, timer)
return defer
def _get_basic_data(self, basic_data, user_id, req, type, timer):
"""
"""
defer = DataBase().get_data(user_id)
defer.addCallback(self._calc_draw, basic_data, req, type, timer)
defer.addErrback(self._draw_failed, req, timer)
return defer
def _calc_create(self, data, req, timer):
union = data.union.get(True)
if union.is_belong_to_union():
#玩家已经属于一个联盟，无法创建联盟
logger.debug("User is belong to union[union_id=%d]" % union.union_id)
res = union_pb2.CreateUnionRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
res.monarch.user_id = data.id
res.monarch.union_id = union.union_id
defer = DataBase().commit(data)
defer.addCallback(self._create_succeed, req, res, timer)
return defer
if not union_business.is_able_to_create_union(data, req.gold_cost, timer.now):
raise Exception("Not able to create union")
#分配联盟 id
union_id = UnionAllocator().allocate()
#请求 Union 模块，创建联盟
union_req = internal_union_pb2.InternalCreateUnionReq()
union_req.user_id = data.id
union_req.name = req.name
union_req.icon_id = req.icon_id
defer = GlobalObject().remote['gunion'].callRemote(
"create_union", union_id, union_req.SerializeToString())
defer.addCallback(self._calc_create_result, data, req, timer)
return defer
def _pack_update_melee_response(self, proxy, data, melee, melee_matcher, mails,
last_battle_win, req, timer):
"""构造返回
args:
Returns:
res[protobuf]: 向客户端的返回的响应
"""
res = arena_pb2.QueryArenaInfoRes()
res.status = 0
pack.pack_melee_info(data.user.get(True), melee, res.arena_info, timer.now, melee_matcher.rank)
#if last_battle_win:
# #对手信息
# rivals_id = melee.generate_arena_rivals_id()
# for rival_id in rivals_id:
# rival = data.rival_list.get(rival_id, True)
# if rival is not None:
# pack.pack_melee_player(rival, res.arena_info.rivals.add())
for mail in mails:
pack.pack_mail_info(mail, res.mails.add(), timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._update_melee_succeed, req, res, timer)
return defer
def _calc_search_result(self, matcher, data, req, timer):
res = union_pb2.SearchUnionRes()
res.status = 0
available = data.union.get(True).is_able_to_join(timer.now)
for union in matcher.result:
message = res.unions.add()
message.id = union.id
message.name = union.get_readable_name()
message.icon_id = union.icon
message.current_number = union.current_number
message.max_number = union.max_number
message.join_status = union.join_status
message.need_level = union.join_level_limit
message.announcement = union.get_readable_announcement()
message.prosperity = union.today_prosperity
message.recent_prosperity = union.recent_prosperity
res.available.append(available)
union = data.union.get(True)
if union.is_belong_to_union():
res.monarch.user_id = data.id
res.monarch.union_id = union.union_id
defer = DataBase().commit(data)
defer.addCallback(self._search_succeed, req, res, timer)
return defer
def _calc_receive_notice(self, data, req, timer):
"""接收到战斗结果通知
1 变更演武场积分
2 新增演武场对战记录
"""
melee = data.melee.get()
(win_score, lose_score) = melee_business.calc_battle_score(melee, req.rival_score)
score_delta = 0
if req.status == MeleeRecordInfo.STATUS_DEFEND_LOSE:
score_delta = lose_score
else:
score_delta = win_score
melee.add_score(score_delta)
record = melee_business.add_melee_record(data,
req.rival_user_id, base64.b64encode(req.rival_name), req.rival_level,
req.rival_icon_id, req.status, score_delta)
mails = []
melee_matcher = MeleeMatcher()
if melee.need_query_rank():
defer = melee_matcher.query_ranking(data, melee)
defer.addCallback(self._update_title_level,
data, melee, melee_matcher, mails, timer)
defer.addCallback(self._check)
else:
defer = Deferred()
defer.addCallback(self._update_title_level,
data, melee, melee_matcher, mails, timer)
defer.addCallback(self._check)
defer.callback(True)
defer = DataBase().commit(data)
defer.addCallback(self._receive_notice_succeed, req, melee, melee_matcher, record, timer)
return defer
def _update_query_info(self, union_response, data, req, timer):
union_res = internal_union_pb2.InternalQueryUnionRes()
union_res.ParseFromString(union_response)
if union_res.status != 0:
raise Exception("Query union res errro")
res = union_pb2.QueryUnionRes()
res.status = 0
res.ret = union_res.ret
if union_res.ret != union_pb2.UNION_OK:
res.ret = union_res.ret
logger.warning("User query union unexpected")
if union_res.ret == union_pb2.UNION_NOT_MATCHED:
union = data.union.get()
if not union.leave_union(union.union_id, timer.now, False):
raise Exception("Leave union failed")
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
else:
return self._patch_query_info(union_res, data, req, timer)
def _pack_query_melee_response(self, proxy, data, melee, melee_matcher, mails, req, timer):
"""构造返回
args:
mails : list(MailInfo)
Returns:
res[protobuf]: 向客户端的返回的响应
"""
res = arena_pb2.QueryArenaInfoRes()
res.status = 0
pack.pack_melee_info(data.user.get(True), melee, res.arena_info, timer.now, melee_matcher.rank)
if melee.is_arena_active(timer.now):
#胜场奖励
if melee.is_able_to_get_win_num_reward():
pack.pack_arena_reward_info(melee, res.arena_info.win_num_reward)
#对手信息
rivals_id = melee.generate_arena_rivals_id()
for rival_id in rivals_id:
rival = data.rival_list.get(rival_id, True)
pack.pack_melee_player(rival, res.arena_info.rivals.add())
#对战记录
record_list = data.melee_record_list.get_all(True)
for record in record_list:
pack.pack_arena_record(record, res.arena_info.records.add())
for mail in mails:
pack.pack_mail_info(mail, res.mails.add(), timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._query_melee_succeed, req, res, timer)
return defer
def _calc_start(self, data, req, timer):
res = internal_union_pb2.InternalStartUnionDonateRes()
res.status = 0
if not data.is_valid():
res.ret = union_pb2.UNION_NOT_MATCHED
return self._start_succeed(data, req, res, timer)
member = member_business.find_member(data, req.user_id)
if member is None:
res.ret = union_pb2.UNION_NOT_MATCHED
return self._start_succeed(data, req, res, timer)
if not donate_business.is_able_to_start_donate(data, req.box_id,
timer):
res.ret = union_pb2.UNION_DONATE_BOX_INVALID
else:
(honor, donate_box) = donate_business.start_donate(
data, req.box_id, req.user_id, req.user_name, req.donate_type,
timer)
res.ret = union_pb2.UNION_OK
res.honor = honor
pack.pack_donate_box_info(data, req.user_id, donate_box,
res.box_info, timer)
donate_records = donate_business.get_donate_records(data)
for donate_record in donate_records:
pack.pack_donate_record_info(donate_record,
res.donate_records.add())
defer = DataBase().commit(data)
defer.addCallback(self._start_succeed, req, res, timer)
return defer
def _calc_use_speed_item(self, data, req, timer):
res = speed_pb2.UseSpeedItemRes()
res.status = 0
building = None
technology = None
if req.HasField("building"):
building_id = BuildingInfo.generate_id(data.id,
req.building.city_basic_id,
req.building.location_index,
req.building.basic_id)
building = data.building_list.get(building_id)
elif req.HasField("tech"):
technology_id = TechnologyInfo.generate_id(data.id,
req.tech.basic_id,
req.tech.type)
technology = data.technology_list.get(technology_id)
item_id = ItemInfo.generate_id(data.id, req.item.basic_id)
item = data.item_list.get(item_id)
use_num = item.num - req.item.num
if not item_business.use_speed_item(item, use_num, building,
technology):
logger.warning("Use speed item failed")
res.return_ret = speed_pb2.UseSpeedItemRes.SPEED_ITEM_ERROR
else:
res.return_ret = 0
compare.check_item(data, req.item)
defer = DataBase().commit(data)
defer.addCallback(self._use_speed_item_succeed, req, res, timer)
return defer
def _calc_query(self, data, req, timer):
if not data.is_valid():
res = internal_union_pb2.InternalQueryUnionDonateRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
return self._query_succeed(data, req, res, timer)
member = member_business.find_member(data, req.user_id)
if member is None:
res = internal_union_pb2.InternalQueryUnionDonateRes()
res.status = 0
res.ret = union_pb2.UNION_NOT_MATCHED
else:
donate_business.auto_refresh_donate_boxes(data, timer)
res = internal_union_pb2.InternalQueryUnionDonateRes()
res.status = 0
res.ret = union_pb2.UNION_OK
donate_boxes = data.donate_box_list.get_all(True)
for donate_box in donate_boxes:
pack.pack_donate_box_info(data, req.user_id, donate_box,
res.boxes_info.add(), timer)
donate_records = donate_business.get_donate_records(data)
for donate_record in donate_records:
pack.pack_donate_record_info(donate_record,
res.donate_records.add())
defer = DataBase().commit(data)
defer.addCallback(self._query_succeed, req, res, timer)
return defer
def _calc_finish_mission(self, data, req, timer):
if not mission_business.finish_mission(req.mission.basic_id, data,
timer.now):
raise Exception("mission not finished.")
#验证
if req.HasField("monarch"):
compare.check_user(data, req.monarch, with_level=True)
for item_info in req.items:
compare.check_item(data, item_info)
#删除当前任务
mission_id = MissionInfo.generate_id(data.id, req.mission.basic_id)
data.mission_list.delete(mission_id)
mission_data = data_loader.AllMission_dict[req.mission.basic_id]
mission_name = mission_business.MissionPool().get_mission_name(
req.mission.basic_id)
if mission_data.type == mission_business.MISSION_TYPE_DAILY and \
mission_name != mission_business.MISSION_VITALITY and \
mission_name != mission_business.MISSION_VIP_LEVEL:
#记录次数
trainer = data.trainer.get()
trainer.add_daily_vitality(1)
if mission_data.type >= 11 and mission_data.type <= 17 and \
mission_name != mission_business.DAY7_MISSION_VITALITY:
trainer = data.trainer.get()
trainer.add_day7_vitality(1)
return DataBase().commit(data)
def _calc_seek_goods(self, data, req, timer):
union = data.union.get(True)
if not union.is_belong_to_target_union(req.index):
#玩家不属于联盟
logger.debug("User is not belong to union")
res = wineShop_pb2.QueryGoodsRes()
res.status = 0
res.invalid = True
else:
type = ShopInfo.GOODS_TYPE_UNION
shop_id = ShopInfo.generate_id(data.id, type)
shop = data.shop_list.get(shop_id)
goods = []
if not shop_business.seek_goods(data, [shop], goods, timer.now):
raise Exception("Seek goods failed")
resource = data.resource.get(True)
res = self._pack_refresh_goods_response(goods, shop, resource, req,
timer.now)
defer = DataBase().commit(data)
defer.addCallback(self._seek_goods_succeed, req, res, timer)
return defer
def _accept_receive(self, data, req, timer):
logger.notice("================ac2")
user = data.user.get()
friend_list = user.get_friends()
index = 0
friends = [id for id in friend_list if id > 0]
if len(friends) >= 30:
return self._pack_manage_wrong_response(friend_pb2.FRIENDFULLOTHER,
data, req, timer)
if not req.friend_id in friend_list:
index = len(friend_list)
friend_list.append(req.friend_id)
user.friends = utils.join_to_string(friend_list)
#初始化好友关系
friendinfo = FriendInfo.create(data.id, req.friend_id, index)
data.friend_list.add(friendinfo)
logger.notice("FRIEND = %d" % len(data.friend_list))
else:
return self._pack_manage_wrong_response(friend_pb2.ALREADYIN, data,
req, timer)
defer = DataBase().commit(data)
res = friend_pb2.ManageFriendsRes()
res.status = 0
res.ret = friend_pb2.FRIEND_OK
defer.addCallback(self._receive_accept_friend_succeed, req, res, timer)
return defer
