def vip_packs_buy(self, msgtype, body):
req = poem_pb.VipPacksBuyRequest()
req.ParseFromString(body)
p = self.player
from entity.manager import save_guide
save_guide(p, req.guide_type) # 保存新手引导进度
now = int(time.time())
today = datedate.fromtimestamp(now)
config = get_config(VipPacksConfig).get(req.ID)
if not config:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
if config.gift_type != VipPackType.Daily:
if now < config.gift_starttime or now > config.gift_lasttime:
return fail_msg(msgtype, msgTips.FAIL_MSG_VIP_PACKS_EXPIRED)
rest = get_vip_pack_rest_count(p, req.ID, today=today)
if rest != -1 and rest <= 0:
return fail_msg(msgtype, reason="次数不足")
if p.vip < config.vip_level:
return fail_msg(msgtype, reason="VIP不足")
cost = parse_reward([{
'count': config.discount_price,
'type': config.discount_price_type}])
gain = parse_reward(config.rewards)
try:
apply_reward(p, gain, cost=cost, type=RewardType.VipPacks)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="消耗不足")
set_vip_packs_limits(p, config.ID, now)
p.vip_packs_today_bought_count += 1
p.save()
p.sync()
return success_msg(msgtype, "")
def gem_compose(self, msgtype, body):
req = poem_pb.GemComposeRequest()
req.ParseFromString(body)
p = self.player
config = get_config(GemConfig).get(req.gemID, None)
if not config:
return fail_msg(msgtype, code=msgTips.FAIL_MSG_INVALID_REQUEST)
if config.gupr <= 0:
return fail_msg(msgtype, code=msgTips.FAIL_MSG_INVALID_REQUEST)
have = p.gems.get(config.ID, 0)
if have >= config.compose_consume:
count = have / config.compose_consume if req.all else 1
cost = config.compose_consume * count
cost = parse_reward(
[dict(type=RewardItemType.Gem, arg=config.ID, count=cost)])
reward = parse_reward(
[dict(type=RewardItemType.Gem, arg=config.gupr, count=count)])
result = apply_reward(p,
reward,
cost=cost,
type=RewardType.GemCompose)
else:
return fail_msg(msgtype, reason='宝石不足')
p.save()
p.sync()
return success_msg(msgtype, '')
def trigger_store_buy(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Store):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
config = get_config(TriggerEventConfig)[p.trigger_event]
goods = get_config(TriggerStoreConfig).get(config.event_param)
if not goods:
return fail_msg(msgtype, reason="没有这个商品")
cost = parse_reward([{
'count': goods.discount_price,
'type': goods.discount_price_type}])
gain = parse_reward([goods.reward])
try:
apply_reward(p, gain, cost=cost, type=RewardType.TriggerStore)
except AttrNotEnoughError as e:
if e.attr == "gold":
return fail_msg(msgtype, reason="钻石不足")
elif e.attr == "money":
return fail_msg(msgtype, reason="金币不足")
else:
return fail_msg(msgtype, reason="消耗不足")
p.trigger_event = 0
p.save()
p.sync()
return success_msg(msgtype, "")
def give_reward(self, date=None):
if not date:
now = int(time.time())
tm = date = datedate.fromtimestamp(now).strftime("%Y-%m-%d")
else:
tm = date
ranking = get_ranking_backup(self.type)
key = ranking.key
ll = get_config(RankingCampaignRewardByGroupConfig).get(
self.config.group, [])
configs = get_config(RankingCampaignRewardConfig)
configs = [configs[i.id] for i in ll]
key = "%s{%s}" % (key, tm)
limit = get_ranking_limit(self.type)
if limit is not None:
rankers = ranking.get_range_by_score(limit,
"+inf",
withscores=True)
else:
rankers = ranking.get_range_by_score("-inf",
"+inf",
withscores=True)
rankers = convert_list_to_dict(rankers, dictcls=OrderedDict).items()
for rank, (entityID, score) in enumerate(rankers, 1):
config = None
for c in configs:
start, end = c.range
if start:
if start > rank:
continue
if end:
if end < rank:
continue
config = c
if not config:
continue
title, content, ID = get_mail("RankingReward")
content = content.format(self.config.day, self.config.title, rank)
if self.type in get_faction_types():
f = Faction.simple_load(entityID, ["leaderID", "memberset"])
for i in set(f.memberset):
if i == f.leaderID:
rewards = parse_reward(config.rewards)
else:
rewards = parse_reward(config.rewards2)
try:
proxy.ranking_send_mail(i, title, content, rewards,
key, ID)
except AttributeError:
pass
else:
rewards = parse_reward(config.rewards)
try:
proxy.ranking_send_mail(entityID, title, content, rewards,
key, ID)
except AttributeError:
pass
def treasure_end(self, msgtype, body):
p = self.player
req = poem_pb.EndTreasure()
req.ParseFromString(body)
if not PlayerTreasureLock.unlock(p.entityID, req.verify_code):
logger.debug("verify_code %s", req.verify_code)
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
if not p.treasure_cache:
logger.debug("not treasure_cache")
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
rewards = []
for type, subtype, count in p.treasure_cache:
if type == TreasureGrid.TreasureGridTypeReward:
rewards.append(poem_pb.RewardData(
type=subtype, count=count))
r1 = parse_reward(req.rewards)
r2 = parse_reward(rewards)
logger.debug("reward %r %r", r1, r2)
if not compare_reward(r1, r2):
logger.debug("compare reward fail")
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
config = get_config(TreasureChestConfig)[p.treasure_type]
gain_chest = bool(req.gain_chest)
if gain_chest:
reward = open_reward(RewardType.Treasure, config.drop)
result = reward.apply_after()
else:
result = {}
result = combine_reward(r1, result)
rsp = poem_pb.EndTreasureResponse()
finisheds = []
finisheds.append(gain_chest)
finisheds.append(bool(req.kill_monster))
need = get_cons_value("TreasureNeedBuffCount")
finisheds.append(len(req.rewards) >= need)
rsp.stars = len(filter(lambda s: s, finisheds))
if rsp.stars == len(finisheds):
rewardex = open_reward(RewardType.Treasure, config.dropex)
rsp.rewardsex = build_reward(rewardex.apply(p))
rsp.finisheds = finisheds
apply_reward(p, result, type=RewardType.Treasure)
build_reward_msg(rsp, result)
now = int(time.time())
p.treasure_used_count += 1
p.treasure_cd = now + 10 * 60
p.treasure_cache = []
refresh_treasure(p)
on_treasure_count(p)
p.save()
p.sync()
return success_msg(msgtype, rsp)
def vip_packs_info(self, msgtype, body):
req = poem_pb.VipPacksInfoRequest()
req.ParseFromString(body)
rsp = poem_pb.VipPacksInfo()
p = self.player
now = int(time.time())
today = datedate.fromtimestamp(now)
configs = get_config(VipPacksConfig)
if req.type == VipPackType.Daily:
try:
config = get_config(VipConfig)[req.vip or p.vip]
except KeyError:
config = get_config(VipConfig)[p.vip]
group = [config.day_giftID]
else:
group = [i.ID for i in get_config(
VipPacksByGroupConfig).get(req.type, [])]
for each in group:
config = configs[each]
if config.gift_type != VipPackType.Daily:
if now < config.gift_starttime or now > config.gift_lasttime:
continue
info = dict(config._asdict())
info["rewards"] = build_reward(parse_reward(info["rewards"]))
# 同组共用一个限购数据
count = get_vip_pack_rest_count(p, each, today=today)
info["count"] = count
rsp.packs.add(**info)
return success_msg(msgtype, rsp)
def give_visit_reward(p=None):
if p:
ps = [p]
else:
ps = g_entityManager.players.values()
# 有积分，发奖励
campaign = g_campaignManager.visit_campaign
campaign_opened = campaign.is_open()
start, final = campaign.get_current_time()
for p in ps:
if not p.pious or not p.visit_group:
continue
configs = get_config(VisitRewardByGroupConfig).get(p.visit_group, [])
if campaign_opened:
if p.visit_time >= start and p.visit_time < final:
continue
for config in configs:
if p.pious >= config.pious:
rewards = parse_reward(config.rewards)
title, content, ID = get_mail("Visit")
content = content.format(p.pious)
send_mail(p.entityID,
title,
content,
addition=rewards,
configID=ID)
p.pious_backup = p.pious
p.pious = 0
p.save()
p.sync()
break
def tip(self, player):
"""打赏
这部分最麻烦的是打赏的类型会根据配置变化，配置变化时必须结算当前打赏收益
"""
config = get_config(ClimbTowerAccreditConfig)[player.climb_tower_floor + 1]
cost = dict(zip(['type', 'arg', 'count'], config.tip))
apply_reward(player, {}, parse_reward([cost]), type=RewardType.ClimbTower)
target = self.challenge(player)
if target['entityID'] > 0:
# 保存打赏收益及次数
idx = self.tip_earnings[config.tip[0]]
idx.pool.execute('HINCRBY', idx.key,
target['entityID'], config.tip[2])
idx.pool.execute('HINCRBY', idx.key,
't%d' % target['entityID'], 1)
now = int(time.time())
self.add_history(target['entityID'], {
"oppID": player.entityID,
"name": player.name,
"prototypeID": player.prototypeID,
"borderID": player.borderID,
"level": player.level,
"faction_name": player.faction_name,
"isWin": False,
"isActive": True, "time": now,
"isRevenge": False,
"tip_type": config.tip[0],
"tip_count": config.tip[2],
})
def city_treasure_recv(self, msgtype, body):
if g_campaignManager.city_dungeon_campaign.is_open():
return fail_msg(msgtype, reason="活动开启中")
if g_campaignManager.city_contend_campaign.is_open():
return fail_msg(msgtype, reason="活动开启中")
p = self.player
info = g_cityDungeon.get_top_info()
top_factionID = info.get("top_factionID", 0)
if not top_factionID:
return fail_msg(msgtype, reason="还没有公会获得宝藏")
if p.factionID != top_factionID:
return fail_msg(msgtype, reason="您不属于这个公会")
if p.city_treasure_recv_flag:
return fail_msg(msgtype, reason="今天已经领取过了")
f = Faction.simple_load(p.factionID, ["faction_treasure"])
if not f.faction_treasure:
return fail_msg(msgtype, reason="还没有公会获得宝藏")
current = None
configs = get_config(CityTreasureRecvConfig)
for config in configs.values():
if f.faction_treasure >= config.treasure_count:
current = config
else:
break
if not current:
return fail_msg(msgtype, reason="没有奖励可以领取")
result = apply_reward(p,
parse_reward(current.rewards),
type=RewardType.CityTreasure)
rsp = poem_pb.CityTreasureRecv()
build_reward_msg(rsp, result)
p.city_treasure_recv_flag = True
p.save()
p.sync()
return success_msg(msgtype, rsp)
def trigger_chest_recv(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Chest):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
req = poem_pb.TriggerChestRecvRequest()
req.ParseFromString(body)
config = get_config(TriggerEventConfig)[p.trigger_event]
chest = get_config(TriggerChestConfig).get(config.event_param)
if not chest:
return fail_msg(msgtype, reason="不存在的宝箱")
if req.is_double:
cost = {"gold": get_cons_value("TriggerChestDoubleCost")}
gain = {}
for i in range(get_cons_value("TriggerChestMultiple")):
gain = combine_reward([chest.reward], [], data=gain)
else:
cost = {}
gain = parse_reward([chest.reward])
try:
apply_reward(p, gain, cost=cost, type=RewardType.TriggerChest)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
p.trigger_event = 0
p.save()
p.sync()
rsp = poem_pb.TriggerChestRecv()
build_reward_msg(rsp, gain)
return success_msg(msgtype, rsp)
def give_reward_by_mail(p):
now = int(time.time())
if not p.groupID:
return
g = Group.simple_load(
p.groupID, ["name", "gve_rewards", "members", "gve_activateds_detail"])
g.gve_rewards.load()
g.gve_activateds_detail.load()
if p.entityID not in g.gve_rewards:
return
rewards, lock, addition = g.gve_rewards[p.entityID]
detail = g.gve_activateds_detail.get(p.entityID, {})
addition = detail.get("addition", 0)
score = detail.get("score", 0)
damage = detail.get("damage", 0)
total_damage = detail.get("total_damage", 0)
title, content, ID = get_mail("GroupBaseReward")
content = content.format(g.name, total_damage, damage, score, addition)
if now >= lock:
for reward in rewards:
reward["count"] = int(reward["count"] *
(1 + addition / float(100)))
rewards = parse_reward(rewards)
if rewards:
send_mail(p.entityID,
title,
content,
addition=rewards,
configID=ID)
del g.gve_rewards[p.entityID]
g.members.load()
member = g.members[p.entityID]
member["intimate"] = member.get("intimate", 0) + 10
g.members[p.entityID] = member
g.save()
def give_reward(self):
ranking = CityDungeonSelfRanking.get_range_by_score(
"-inf", "+inf", withscores=True)
configs = get_config(CityDungeonRewardConfig)
from campaign.manager import g_campaignManager
start_time = g_campaignManager.city_dungeon_campaign.get_start_time()
final_time = g_campaignManager.city_dungeon_campaign.get_final_time()
for rank, (entityID, score) in enumerate(
convert_list_to_dict(ranking, dictcls=OrderedDict).items(), 1):
if not rank:
continue
for c in configs.values():
start, end = c.range
if start:
if start > rank:
continue
if end:
if end < rank:
continue
config = c
if not config:
continue
title, content, ID = get_mail("CityDungeon")
content = content.format(rank)
rewards = parse_reward(config.rewards)
key = "CityDungeon{%d}{%d}" % (start_time, final_time)
try:
proxy.city_send_mail(
entityID, title, content, rewards, key, ID)
except AttributeError:
pass
def get_panel(self, p, rsp):
if self.is_top_faction(p.factionID): # 防守方
rsp.self_rank = CityContendDefendRanking.get_rank(p.entityID)
if not rsp.self_rank:
CityContendDefendRanking.update_score(p.entityID, 0)
rsp.self_ranking = self.get_player_ranking(
CityContendDefendRanking)
if not p.city_contend_treasure:
configs = get_config(CityTreasureConfig)
config = configs.get(p.level)
if not config:
config = configs[max(configs)]
p.city_contend_treasure = config.defend_treasure
p.save()
p.sync()
else: # 攻击方
rsp.self_rank = CityContendAttackRanking.get_rank(p.entityID)
if not rsp.self_rank:
CityContendAttackRanking.update_score(p.entityID, 0)
rsp.faction_rank = CityContendFactionRanking.get_rank(p.factionID)
if not rsp.faction_rank:
CityContendFactionRanking.update_score(p.factionID, 0)
rsp.self_ranking = self.get_player_ranking(
CityContendAttackRanking)
rsp.faction_ranking = self.get_faction_ranking(
CityContendFactionRanking)
rsp.reds = list(g_redManager.get_red_messages(
module=RedModuleType.CityContendDefend)) + list(
g_redManager.get_red_messages(
module=RedModuleType.CityContendAttack))
rsp.events = self.get_events(p)
rsp.rewards = build_reward(parse_reward(p.city_contend_rewards))
f = Faction.simple_load(p.factionID, ["faction_treasure"])
rsp.faction_treasure = f.faction_treasure
def trigger_chests_recv(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Chests):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
config = get_config(TriggerEventConfig)[p.trigger_event]
chest = get_config(TriggerChestsConfig).get(config.event_param)
if len(p.trigger_chests) > 0:
cost = {"gold": get_cons_value("TriggerChestsMoreCost")}
else:
cost = {}
rests = set(range(len(chest.rewards))) - p.trigger_chests
if not rests:
return fail_msg(msgtype, reason="已经没有宝箱了")
index = choice_one(list(rests))
is_best = False
if index == 0:
p.trigger_event = 0
is_best = True
gain = parse_reward([chest.rewards[index]])
try:
apply_reward(p, gain, cost=cost, type=RewardType.TriggerChests)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
p.trigger_chests.add(index)
p.save()
p.sync()
rsp = poem_pb.TriggerChestsRecv(is_best=is_best)
build_reward_msg(rsp, gain)
return success_msg(msgtype, rsp)
def trigger_chests_info(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Chests):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
config = get_config(TriggerEventConfig)[p.trigger_event]
chest = get_config(TriggerChestsConfig).get(config.event_param)
reward = chest.rewards[0] # 默认第一个是最好的
rsp = poem_pb.TriggerChestsInfo(
more_cost=get_cons_value("TriggerChestsMoreCost"))
build_reward_msg(rsp, parse_reward([reward]))
return success_msg(msgtype, rsp)
def trigger_store_info(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Store):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
config = get_config(TriggerEventConfig)[p.trigger_event]
goods = get_config(TriggerStoreConfig).get(config.event_param)
if not goods:
return fail_msg(msgtype, reason="没有这个商品")
info = goods._asdict()
info["rewards"] = build_reward(parse_reward([goods.reward]))
rsp = poem_pb.TriggerStoreInfo(**info)
return success_msg(msgtype, rsp)
def visit_reward(self, msgtype, body):
campaign = g_campaignManager.visit_campaign
if campaign.is_open():
group = campaign.get_current().reward_group
else:
group = 1
configs = get_config(VisitRewardByGroupConfig).get(group)
rsp = poem_pb.VisitRewardResponse()
for config in sorted(configs, key=lambda s: s.pious, reverse=True):
info = config._asdict()
info["rewards"] = build_reward(parse_reward(config.rewards))
rsp.items.add(**info)
return success_msg(msgtype, rsp)
def tally_up(self, player):
"""结算收益"""
if not player:
return
cd = player.climb_tower_accredit_cd
floor = player.climb_tower_accredit_floor
if floor in self.floors:
# 统一的结束时间
payoff = self.floors[floor].payoff
if payoff > player.climb_tower_accredit_stash_time and payoff < cd:
player.climb_tower_accredit_cd = cd = payoff
player.save()
if floor > 0 and cd > 0 and cd <= int(time.time()):
# 派驻到期
config = get_config(ClimbTowerAccreditConfig)[floor]
payload = dict(type=config.earnings[0], arg=config.earnings[0],
count=player.climb_tower_accredit_acc_earnings)
rewards = [payload] if payload['count'] > 0 else []
clear = []
fields = ['t%d' % player.entityID, player.entityID]
# 结算所有类型打赏收益
for kind, idx in self.tip_earnings.items():
tip = int(idx.pool.execute('HGET', idx.key, player.entityID) or 0)
if tip > 0:
earnings = dict(type=kind,
arg=kind,
count=tip)
rewards.append(earnings)
clear.append(idx)
logger.info('tally_up: %d, %s' % (player.entityID, rewards))
reward = parse_reward(rewards)
title, content, ID = get_mail('ClimbTowerAccredit')
dt = datetime.fromtimestamp(cd)
send_mail(player.entityID, title=title,
content=content.format(dt.strftime('%Y-%m-%d')),
addition=reward, configID=ID)
self.floors[floor].idx.unregister(player.entityID)
player.climb_tower_accredit_stash_time = 0
player.climb_tower_accredit_cd = 0
player.climb_tower_accredit_stash_earnings = 0
player.climb_tower_accredit_floor = 0
player.save()
player.sync()
for idx in clear:
idx.pool.execute('HDEL', idx.key, *fields)
def send_flower_boss_mail_offline(entityID, configID, rank, damage):
if not configID:
return
p = Player.simple_load(entityID, ['friendfb_kill_count'])
p.friendfb_kill_count += 1
config = get_config(FriendfbRewardConfig).get(configID)
rewards = {}
if config:
rewards = parse_reward(config.rewards)
p.save()
title, content, ID = get_mail("FlowerBoss")
content = content.format(damage, rank)
do_send_mail(entityID, title, content, addition=rewards, configID=ID)
return True
def advance_equip(p, petID, equipID, equips):
pet = p.pets.get(petID)
if not pet:
return msgTips.FAIL_MSG_INVALID_REQUEST
equip = get_or_create_equip(p, pet, equipID)
if not equip:
return msgTips.FAIL_MSG_INVALID_REQUEST
equip_config = get_config(NewEquipConfig).get(equip.prototypeID)
if not equip_config:
return msgTips.FAIL_MSG_INVALID_REQUEST
binding = p.equipeds.get(equip.entityID)
if petID != binding:
return msgTips.FAIL_MSG_INVALID_REQUEST
advance_configs = get_config(EquipAdvanceConfig)
advance_config = advance_configs.get(equip.step)
if equip.step + 1 > max(advance_configs):
return msgTips.FAIL_MSG_INVALID_REQUEST
# 宠物必须满足等级要求
if pet.level < advance_config.level:
return msgTips.FAIL_MSG_INVALID_REQUEST
advance_cost_config = get_config(EquipAdvanceCostConfig).get(
equip_config.gup_id)
if not advance_cost_config:
return msgTips.FAIL_MSG_INVALID_REQUEST
cost = parse_reward(advance_cost_config.costs[equip.step - 1])
combine_reward({"money": advance_config.money}, {}, data=cost)
equipList = sorted([i[0] for i in cost.pop("equipList", [])])
try: # 扣除装备，宠物 TODO
equips = [p.equips[i] for i in equips]
equips_prototypeID = sorted([i.prototypeID for i in equips])
if len(equips_prototypeID) != len(equipList):
raise KeyError
for i in range(len(equips_prototypeID)):
if equips_prototypeID[i] != equipList[i]:
raise KeyError
apply_reward(p, {}, cost, type=RewardType.EquipAdvance)
p.del_equips(*equips)
except KeyError:
return msgTips.FAIL_MSG_INVALID_REQUEST
except (AttrNotEnoughError or MatNotEnoughError):
return msgTips.FAIL_MSG_INVALID_REQUEST
equip.step += 1
from task.manager import on_advance_equip
on_advance_equip(p, equip)
update_ranking_equip(p, equip)
equip.save()
equip.sync()
p.save()
p.sync()
return SUCCESS
def send_flower_boss_mail(entityID, configID, rank, damage):
if not configID:
return
p = g_entityManager.get_player(entityID)
p.friendfb_kill_count += 1
p.save()
p.sync()
config = get_config(FriendfbRewardConfig).get(configID)
rewards = {}
if config:
rewards = parse_reward(config.rewards)
title, content, ID = get_mail("FlowerBoss")
content = content.format(damage, rank)
do_send_mail(entityID, title, content, addition=rewards, configID=ID)
return True
def get_campaign_info(p, dlcID):
from task.manager import get_task_info
from task.manager import get_plan
campaign = g_dlcCampaignManager.campaigns.get(dlcID)
if not campaign or not campaign.is_open():
return
rsp = poem_pb.DlcCampaignInfo()
today = datedate.today()
dlc_tasks = p.dlc_tasks.get(dlcID, [])
task = None
count = 0
total = len(dlc_tasks)
configs = get_config(DlcTaskConfig)
infos = get_config(TaskConfig)
cost = 0
for i in sorted(dlc_tasks):
dlc_task = configs[i]
info = infos[i]
is_done = get_plan(p, i, today) >= info.goal
if dlc_task.rewards:
rsp.nodes.add(
rewards=build_reward(
parse_reward(dlc_task.rewards)),
can_receive=(i in p.taskrewards),
is_done=is_done,
index=dlc_task.index)
if is_done:
count += 1
if task is None:
if i in p.taskrewards:
task = get_task_info(p, i, today)
cost = dlc_task.gold
elif task is None:
task = get_task_info(p, i, today)
cost = dlc_task.gold
if task:
now = int(time.time())
rsp.campaign_cd = max(campaign.get_end_time() - now, 0)
rsp.task = task
rsp.count = count
rsp.total = total
rsp.cost = cost
cd = p.dlc_tasks_cd.get(dlcID, 0)
if cd:
rsp.cd = max(cd - now, 0)
return rsp
return None
def dlc_star_packs_info(self, msgtype, body):
p = self.player
req = poem_pb.DlcStarPacksInfoRequest()
req.ParseFromString(body)
group = get_config(DlcStarPacksByDlcConfig).get(req.dlcID, [])
configs = get_config(DlcStarPacksConfig)
rsp = poem_pb.DlcStarPacksInfo()
for each in group:
config = configs[each.ID]
if each.ID in p.dlc_star_packs_end:
continue
rsp.packs.add(
id=config.ID, star=config.score,
rewards=build_reward(
parse_reward(config.rewards)))
# rsp.rank = get_current_rank("DLC%d" % req.dlcID, p.entityID)
return success_msg(msgtype, rsp)
def dlc_star_packs_recv(self, msgtype, body):
req = poem_pb.DlcStarPacksRecv()
req.ParseFromString(body)
p = self.player
if req.id in p.dlc_star_packs_end:
return fail_msg(msgtype, reason="领过了")
config = get_config(DlcStarPacksConfig).get(req.id)
if not config:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
score = get_dlc_score(p, config.dlcID)
if score < config.score:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
apply_reward(
p, parse_reward(config.rewards),
type=RewardType.DlcStarPacks)
p.dlc_star_packs_end.add(req.id)
p.save()
p.sync()
return success_msg(msgtype, '')
def give_reward(p, rewards=None):
if not rewards:
rs = pool.execute("HGET", BOSS_REWARD, p.entityID)
if rs:
rewards = cPickle.loads(rs)
else:
return
for key, info in rewards.items():
if key in p.boss_campaign_rewards:
continue
title, content, ID = get_mail("BossKill")
content = content.format(info.get("damage", 0), info.get("rank", 0))
send_mail(p.entityID,
title,
content,
addition=parse_reward(info.get("rewards", {})),
configID=ID)
p.boss_campaign_rewards.add(key)
p.save()
pool.execute("HDEL", BOSS_REWARD, p.entityID)
def give_reward(self, key=None, p=None):
if not key:
date = datedate.today() - timedelta(days=1)
key = self.backup_key(date)
if key not in self.rewards:
self.dump_rewards(key)
ranking = SwapRanking(Player,
'swaprank',
pool=settings.REDISES['index'],
register_on_create=False,
key=key)
if key not in self.rewards:
self.dump_rewards(key)
# ranking = PlayerSwapRankRanking
if p:
ps = [p]
else:
ps = g_entityManager.players.values()
t, configs = self.rewards[key]
for p in ps:
if key in p.pvprankreceiveds:
continue
rank = ranking.get_rank(p.entityID)
if not rank:
continue
for config in configs.values():
start, end = config["range"]
if start:
if start > rank:
continue
if end:
if end < rank:
continue
rewards = parse_reward(config["rewards"])
tm = datedate.fromtimestamp(t).strftime(DATE_FMT)
title, content, ID = get_mail("SwapRank")
content = content.format(tm, rank)
self.send_mail(p, title, content, rewards, key, ID)
break
def gem_refine(self, msgtype, body):
req = poem_pb.GemRefineRequest()
req.ParseFromString(body)
p = self.player
if not hasattr(p, 'inlay%d' % req.index):
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
inlay = getattr(p, 'inlay%d' % req.index)
config = get_config(GemRefineConfig).get(inlay + 1)
if not config:
return fail_msg(msgtype, reason='满级了')
kind = {1: 11, 2: 12, 3: 13, 4: 14, 5: 15}[req.index]
refine_cfg = get_config(PlayerRefineConfig)[kind]
cost = [
dict(type=config.cost_type,
arg=config.cost_type,
count=config.cost)
]
gems = match_gems(req.index, inlay + 1)
cost.extend(
[dict(type=RewardItemType.Gem, arg=g.ID, count=1) for g in gems])
try:
result = apply_reward(p, {},
cost=parse_reward(cost),
type=RewardType.GemRefine)
except AttrNotEnoughError as e:
return fail_msg(msgtype, reason='消耗不足')
except GemNotEnoughError:
return fail_msg(msgtype, reason='宝石不足')
count = 1
setattr(p, "inlay%d" % req.index, inlay + count)
p.clear_equip_power()
p.clear_power()
p.save()
p.sync()
return success_msg(msgtype, '')
def faction_recv_level_reward(self, msgtype, body):
p = self.player
req = poem_pb.RecvLevelReward()
req.ParseFromString(body)
config = get_config(FactionLevelRewardConfig).get(req.level)
if not config:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
if req.level != p.faction_level:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
if p.faction_level_rewards_received:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
rewards = []
for i, _ in enumerate(config.types):
rewards.append(
poem_pb.RewardData(type=config.types[i],
arg=config.itemIDs[i],
count=config.amounts[i]))
rewards = parse_reward(rewards)
apply_reward(p, rewards, type=RewardType.FactionLevelReward)
p.faction_level_rewards_received.add(req.level)
p.save()
p.sync()
return success_msg(msgtype, '')
def checkWaterWormReward(self, p):
from protocol import poem_pb
rsp = poem_pb.SeedWateringWormingResponse()
if p.watering_used_count >= p.watering_max_count and p.worming_used_count >= p.worming_max_count:
import random
from config.configs import get_cons_string_value
rt = random.randint(1, 2)
ww_reward = get_cons_string_value("CampaignWWReward_" + str(rt))
tmp = map(int, ww_reward.split('|'))
info = {}
info["type"] = tmp[0]
info["arg"] = tmp[1]
info["count"] = tmp[2]
rsp.rewards.add(**info)
from reward.manager import RewardType
from reward.manager import apply_reward
from reward.manager import parse_reward
apply_reward(p,
parse_reward([info]),
type=RewardType.SeedWaterWormCampaign)
return rsp
def give_gve_ranking_reward(entityID):
from config.configs import get_config
from config.configs import GveRankingRewardConfig
from reward.manager import parse_reward
from mail.manager import send_mail
from mail.manager import get_mail
try:
entityID = int(entityID)
except ValueError:
return FAILURE
try:
configID = int(request.POST.getone("configID", 0))
except ValueError:
return FAILURE
group_name = request.POST.getone("group_name", u"")
group_damage = request.POST.getone("group_damage", 0)
group_rank = request.POST.getone("group_rank", 0)
date = request.POST.getone("date", u"")
if not date:
return FAILURE
from player.model import Player
if not int(
Player.pool.execute("HSET", "gve_ranking_rewards_p{%d}" % entityID,
date, "")):
# 不让重复添加
return SUCCESS
config = get_config(GveRankingRewardConfig).get(configID)
if not config:
return FAILURE
title, content, ID = get_mail("GroupRankReward")
try:
content = content.format(group_name, group_damage, group_rank)
except UnicodeDecodeError:
pass
rewards = parse_reward(config.rewards)
send_mail(entityID, title, content, addition=rewards, configID=ID)
return SUCCESS
