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 flowerboss_friendfb_reborn(self, msgtype, body):
req = poem_pb.RebornFriendfb()
req.ParseFromString(body)
p = self.player
try:
hp, fbID = simple_load_friendfb(req.friendfbID, 'hp', 'fbID')
except DoesNotExistsException:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED)
if hp <= 0:
return fail_msg(msgtype, reason='BOSS已经被击杀了')
if not player_is_dead(p, req.friendfbID):
return fail_msg(msgtype, reason="无须复活")
count = p.friendfb_reborn_counts[req.friendfbID] =\
p.friendfb_reborn_counts.get(req.friendfbID, 0) + 1
cost = get_cons_value("FlowerBossRebornCost") * count
try:
apply_reward(p, {},
cost={"gold": cost},
type=RewardType.FriendfbReborn)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
p.friendfb_deads.remove(req.friendfbID)
if fbID in p.friendfb_deadtimes:
del p.friendfb_deadtimes[fbID]
p.friendfb_buff = get_cons_value("GveBuffAddition")
p.save()
p.sync()
return success_msg(msgtype, "")
def gve_reborn(self, msgtype, body):
p = self.player
if not gve_is_open(p):
return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_GVE_NOT_OPEN)
if gve_is_end(p):
return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_GVE_ALREADY_END)
end_time = g_campaignManager.gve_campaign.get_end_time()
if p.gve_state != GveEntity.GveEntityStateDead:
return fail_msg(msgtype, reason="没有死亡")
if p.gve_reborn_rest_count <= 0:
return fail_msg(msgtype, reason="没有复活次数了")
try:
apply_reward(
p, {},
cost={"gold": get_cons_value("GveRebornCost")},
type=RewardType.GveReborn)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
count = int(Group.pool.execute(
"SREM", "gve_deads_g{%s}" % p.groupID, p.entityID))
g = Group.simple_load(
p.groupID, ["gve_end_cd", "gve_activateds"])
g.gve_activateds.load()
if count < len(g.gve_activateds):
g.gve_end_cd = end_time
g.save()
p.gve_state = GveEntity.GveEntityStateNormal
p.gve_buff = get_cons_value("GveBuffAddition")
p.gve_reborn_rest_count -= 1
sync_gve_entity(g.gve_activateds, p.entityID)
p.save()
p.sync()
return success_msg(msgtype, "")
def enchant(self, msgtype, body):
p = self.player
req = EnchantEquip()
req.ParseFromString(body)
need = pow(2, len(req.locks))
enchant_free_used_count = 0
if req.ex:
need *= get_cons_value("EnchantExCostBase")
else:
if p.enchant_free_rest_count:
need = 0
enchant_free_used_count = 1
else:
need *= get_cons_value("EnchantCostBase")
if need:
if p.stone < need:
gold = (need - p.stone) * get_cons_value("EnchantStoneToGold")
cost = {"stone": p.stone, "gold": gold}
else:
cost = {"stone": need}
try:
apply_reward(p, {}, cost=cost, type=RewardType.EnchantEquip)
except (AttrNotEnoughError, MatNotEnoughError):
return fail_msg(msgtype, reason="消耗不足")
enchant_equip(p, req.equipID, locks=req.locks, ex=req.ex)
p.enchant_free_used_count += enchant_free_used_count
p.save()
p.sync()
return success_msg(msgtype, "")
def treasure_enter(self, msgtype, body):
p = self.player
if not p.treasure_count:
return fail_msg(msgtype, reason="not enough challenge times")
now = int(time.time())
if p.treasure_cd > now:
return fail_msg(msgtype, reason="CD冷却中")
rsp = enter_treasure(p)
rsp.verify_code = PlayerTreasureLock.lock(p.entityID, force=True)
rsp.need_count = get_cons_value("TreasureNeedBuffCount")
rsp.round_count = get_cons_value("TreasureRoundCount")
logger.debug(rsp)
p.save()
p.sync()
return success_msg(msgtype, rsp)
def __init__(self):
self.campaigns = {}
self.deadline = 0
self.reserved = 0
configs = get_config(RankingCampaignConfig)
for day, config in configs.items():
campaign = self.campaigns[config.ranking] = RankingCampaign(config)
campaign.start()
deadline = config.final + get_cons_value(
"RankingCampaignDeadlineTime")
reserved = config.start + get_cons_value(
"RankingCampaignReservedTime")
if deadline > self.deadline:
self.deadline = deadline
if not reserved or reserved < self.reserved:
self.reserved = reserved
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 mall_open(self, msgtype, body):
p = self.player
req = poem_pb.MallOpen()
req.ParseFromString(body)
logger.debug(req)
cost = 0
if req.type == MallType.Golden:
if p.mall_golden_open_cost:
cost = p.mall_golden_open_cost
f = 'mall_golden_opened'
n = 'OpenGoldenMallCost'
elif req.type == MallType.Silver:
if p.mall_silver_open_cost:
cost = p.mall_silver_open_cost
f = 'mall_silver_opened'
n = 'OpenSilverMallCost'
if not cost:
return fail_msg(msgtype, reason="不满足开启条件")
try:
apply_reward(
p, {}, {'gold': get_cons_value(n)}, type=RewardType.MallOpen)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
setattr(p, f, True)
refresh_mall(p, req.type)
p.save()
p.sync()
return success_msg(msgtype, '')
def reborn(self, msgtype, body):
p = self.player
cost = get_cons_value("DailyRebornCost")
# if not g_campaignManager.dailypvp_campaign.is_open():
# return fail_msg(msgtype, msgTips.FAIL_MSG_DAILY_CAMPAIGN_CLOSED)
try:
apply_reward(
p, {}, cost={"gold": cost}, type=RewardType.DailyPVPReborn)
except AttrNotEnoughError:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
changeds = set()
lineups = [
p.lineups.get(LineupType.Daily, []),
p.lineups.get(LineupType.City, []),
]
for lineup in lineups:
for each in lineup:
pet = p.pets.get(each)
if pet:
pet.daily_dead = False
pet.daily_restHP = 0
changeds.add(pet)
for pet in changeds:
pet.save()
pet.sync()
p.daily_dead_cd = 0
p.save()
p.sync()
return success_msg(msgtype, "")
def friend_friendfb_detail(self, msgtype, body):
p = self.player
req = poem_pb.FriendfbDetailRequest()
req.ParseFromString(body)
rsp = poem_pb.FriendfbDetail()
friendfb = load_friendfb(req.friendfbID)
logger.debug("detail %r", friendfb)
if not friendfb:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED)
config = get_config(FriendfbConfig)[friendfb['fbID']]
friendfb.update(**config._asdict())
if p.entityID in friendfb['activists']:
friendfb['done'] = True
rsp.friendfb = poem_pb.Friendfb(**friendfb)
rsp.rewards = config.rewards
# # 排行榜
# ranks = load_ranks(req.friendfbID)
# for rank in ranks:
# rsp.ranks.add(**rank)
rsp.is_dead = player_is_dead(p, req.friendfbID)
rsp.reborn_cost = (p.friendfb_reborn_counts.get(req.friendfbID, 0) +
1) * get_cons_value("FriendfbRebornCost")
logger.debug(rsp)
return success_msg(msgtype, rsp)
def ambition_up(self, msgtype, body):
p = self.player
req = poem_pb.AmbitionUpRequest()
req.ParseFromString(body)
if not req.type:
configs = get_config(AmbitionConfig)
level = p.level
ambition = str(p.ambition) or ''
attr = "ambition"
else:
configs = get_config(VipAmbitionConfig)
level = p.vip
ambition = str(p.vip_ambition) or ''
attr = "vip_ambition"
index = req.index or 0
config = configs.get(index + 1)
if not config:
return fail_msg(msgtype, reason="没有下一个了")
if level < config.level:
return fail_msg(msgtype, reason="等级不足")
random_configs = get_config(RandomAmbitionConfig)
if req.use_gold:
c = weighted_random2([[
i.step, i.golden_pro] for i in random_configs.values()])
cost = {"gold": get_cons_value("AmbitionGoldUpCost")}
else:
c = weighted_random2([[
i.step, i.pro] for i in random_configs.values()])
cost = {"soul": get_cons_value("AmbitionUpCost")}
if c not in random_configs:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
try:
ll = list(ambition)
ll[index] = str(c)
ambition = ''.join(ll)
except IndexError:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
apply_reward(p, {}, cost, type=RewardType.AmbitionUp)
setattr(p, attr, ambition)
if c >= 5:
p.ambition_count += 1
from task.manager import on_ambition
on_ambition(p)
p.save()
p.sync()
return success_msg(msgtype, "")
def trigger_chest_info(self, msgtype, body):
p = self.player
if not check_trigger_event_type(p, EventType.Chest):
return fail_msg(msgtype, reason="无触发事件或错误的事件类型")
# config = get_config(TriggerEventConfig)[p.trigger_event]
rsp = poem_pb.TriggerChestInfo(
double_cost=get_cons_value("TriggerChestDoubleCost"))
return success_msg(msgtype, rsp)
def get_helper_cd(p, entityID, now=None):
if not now:
now = int(time.time())
dlc_cd = 0
last = p.dlc_helpers.get(entityID, 0)
if last:
dlc_cd = max(
get_cons_value("DlcHelperCD") - (now - last), 0)
return dlc_cd
def get_hurts(monster):
prob = get_cons_value("TapCritProb") / float(100)
hurts = []
while sum(hurts) < monster.hp:
if guess(prob):
hurts.append(HURT_CRIT)
else:
hurts.append(HURT_NORM)
return hurts
def treasure_refresh(self, msgtype, body):
p = self.player
try:
apply_reward(
p, {},
cost={'gold': get_cons_value("TreasureRefreshGold")},
type=RewardType.TreasureRefresh)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
refresh_treasure(p)
return success_msg(msgtype, "")
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 maze_step(self, msgtype, body):
p = self.player
req = poem_pb.MazeStepRequest()
req.ParseFromString(body)
count = p.maze_rest_count if req.onekey else 1
# check count
if count > p.maze_rest_count:
return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
gains = {}
attr = {}
mazes = []
incr = {}
results = step_mazes(p, attr, incr, count)
count = len(results)
rsp = poem_pb.MazeStepResponse()
for each in results:
drop = each.get("drop", 0)
if drop:
maze_drop = open_reward(RewardType.MazeDrop, drop)
rewards = maze_drop.apply_after()
gains = combine_reward(rewards, {}, data=gains)
if each.get("append", False):
mazes.append(each)
drop = get_cons_value("MazeMustDropID")
must_drop = open_reward(RewardType.MazeDrop, drop)
rewards = must_drop.apply_after()
gains = combine_reward(rewards, {}, data=gains)
rsp.events.add(**each)
rsp.rewards = build_reward(gains)
for each in mazes:
p.mazes.append(each)
apply_reward(p, gains, type=RewardType.MazeDrop)
for each, value in attr.items():
setattr(p, each, value)
for each, value in incr.items():
setattr(p, each, getattr(p, each) + value)
if "mall_silver_open_remain" in attr:
try:
del p.malls[MallType.Silver]
except KeyError:
pass
if "mall_golden_open_remain" in attr:
try:
del p.malls[MallType.Golden]
except KeyError:
pass
p.touch_mazes()
p.maze_step_count += count
on_maze_count(p, count)
p.save()
p.sync()
return success_msg(msgtype, rsp)
def treasure_clean_cd(self, msgtype, body):
p = self.player
try:
apply_reward(
p, {},
cost={'gold': get_cons_value("TreasureCleanCDGold")},
type=RewardType.TreasureCleanCD)
except AttrNotEnoughError:
return fail_msg(msgtype, reason="钻石不足")
p.treasure_cd = 0
p.save()
p.sync()
return success_msg(msgtype, '')
def recv_red(self, red):
# -1 被领取完了， 0 超时， 1成功
rest = index_pool.execute("HINCRBY", red, "count", -1)
if rest < 0:
index_pool.execute("HINCRBY", red, "count", 1)
return -1
t = index_pool.execute("HGET", red, "time")
if time.time() > int(t):
index_pool.execute("HINCRBY", red, "count", 1)
return 0
return int(
index_pool.execute("HGET", red, "drop")
or get_cons_value("DailyRed"))
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 create_player(player):
config = get_config(CreatePlayerConfig)[player.sex, player.career]
player.mats[config.prototypeID] = 1
player.prototypeID = config.prototypeID
player.mats[config.borderID] = 1
player.borderID = config.borderID
player.money = config.money
player.gold = config.gold
player.level = config.level
player.createtime = datetime.now()
player.last_check_mail_time = time.mktime(player.createtime.timetuple())
player.sp = config.sp
player.spmax = player.sp
player.petmax = config.petmax
player.new_role = True
player.add_pets(*[{"prototypeID": p} for p in config.petIDs])
player.skillpoint = player.skillpoint_max
player.maze_rest_count = player.maze_most_count
player.lottery_gold_accumulating = config.accumulating
# # 新号过滤已过期签到天数
# player.check_in_over_count = max(player.createtime.day - 1, 0)
# player.check_in_used_count = player.check_in_over_count
from task.manager import trigger_seven_task
trigger_seven_task(player)
init_lineups(player)
if config.drop:
from reward.manager import open_reward, RewardType
reward = open_reward(RewardType.CreatePlayer, config.drop)
reward.apply(player)
# wish
if get_cons_value("WishNewPlayerExperienceFlag"):
player.wish_experience_time = time.mktime(
player.createtime.timetuple()) + get_cons_value(
"WishNewPlayerExperienceTime")
player.save()
return player
def get_panel(self, p, rsp):
lives = self.get_lives(count=10)
rsp.lives = lives
rankers = self.get_rankers(count=10)
rsp.ranks = rankers
rsp.rewards = build_reward(p.daily_rewards)
rsp.reds = g_redManager.get_red_messages()
# 检查战斗期间内是否被已死亡
rsp.registers = PlayerDailyRankRanking.count()
p.clear_daily_dead()
if p.daily_dead and p.daily_count:
now = int(time.time())
p.daily_dead_cd = now + get_cons_value("DailyDeadCD")
self.pool.execute("DEL", "daily_dead_p{%d}" % p.entityID)
p.clear_daily_dead()
p.save()
p.sync()
return rsp
def faction_alter_name(self, msgtype, body):
p = self.player
factionID = self.player.factionID
if not factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
faction = Faction.simple_load(factionID, ['leaderID', 'name'])
if self.player.entityID != faction.leaderID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_PERMISSION_DENIED)
req = poem_pb.AlterNameFaction()
req.ParseFromString(body)
cost = get_cons_value("FactionAlterNameGold")
if p.gold < cost:
return fail_msg(msgtype, reason="钻石不足")
name, err = validate_name(req.name)
if err:
return fail_msg(msgtype, err)
try:
FactionnameIndexing.register(factionID, req.name)
except DuplicateIndexException:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_DUPLICATE_FACTION_NAME)
FactionnameIndexing.unregister(faction.name)
apply_reward(p, {},
cost={"gold": cost},
type=RewardType.FactionAlterName)
faction.name = req.name
p.save()
p.sync()
faction.save()
notify_change(factionID)
gm_logger.info({
'faction': {
'entityID': p.entityID,
'type': 'altername_faction',
'factionName': faction.name,
'factionID': faction.factionID,
}
})
return success_msg(msgtype, '')
def battle(self, p, targetID, fight, raw, rsp):
target_win_count = 0 # 对手连胜次数
max_win_count = 0
history = None # 战斗记录
shutdown = False
self_message = ""
full_message = ""
horn = False
red_message = ""
red_count = 0
self_shutdown_message = ""
full_shutdown_message = ""
peer_shutdown_message = ""
count = 0
rsp.before_daily_win_count = p.daily_win_count
if fight.fightResult: # 胜利
# 终结对手连胜
target_win_count = int(self.pool.execute(
"GETSET", "daily_win_count_p{%d}" % targetID, 0) or 0)
self.pool.execute("SET", "daily_dead_p{%d}" % targetID, 1)
# 添加自己连胜
daily_win_count = int(self.pool.execute(
"INCRBY", "daily_win_count_p{%d}" % p.entityID, 1) or 0)
p.clear_daily_win_count()
# 更新最大连胜次数
if p.daily_win_count > p.daily_max_win_count:
p.daily_max_win_count = p.daily_win_count
count = update_daily_rank(
PlayerDailyRankRanking, p.entityID, p.daily_max_win_count)
# PlayerDailyRankRanking.update_score(
# p.entityID, p.daily_max_win_count)
# 连胜任务
from task.manager import on_dailypvp_count
on_dailypvp_count(p, p.daily_max_win_count)
# 取全服最大次数
top = PlayerDailyRankRanking.get_range_by_score(
"-inf", "+inf", withscores=True, count=1)
if top:
max_win_count = top[1]
rsp.max_win_count = max_win_count
daily_win_config = get_config(DailyWinConfig).get(
p.daily_win_count)
if not daily_win_config and \
p.daily_win_count > max(get_config(DailyWinConfig)):
daily_win_config = get_config(
DailyWinConfig)[max(get_config(DailyWinConfig))]
if daily_win_config:
if not daily_win_config.multiple or (
daily_win_config.multiple and count == 1):
self_message = daily_win_config.single_desc
full_message = daily_win_config.all_desc
horn = daily_win_config.horn
if daily_win_config.red_paper:
red_message = daily_win_config.red_paper_desc
red_count = daily_win_config.red_paper_count
red_drop = daily_win_config.red_paper
daily_lose_config = get_config(DailyLoseConfig).get(
target_win_count)
if not daily_lose_config and \
target_win_count > max(get_config(DailyLoseConfig)):
daily_lose_config = get_config(
DailyLoseConfig)[max(get_config(DailyLoseConfig))]
if daily_lose_config:
self_shutdown_message = daily_lose_config.single_win_desc
peer_shutdown_message = daily_lose_config.single_lose_desc
full_shutdown_message = daily_lose_config.all_desc
# 增加胜利次数
p.daily_kill_count += 1
# 奖励加成系数
multi = min(40, 2 * daily_win_count) + min(
80, target_win_count * 4)
shutdown = target_win_count > 2
history = {
"active": False, "name": p.name,
"win": not fight.fightResult,
"faction_name": p.faction_name,
"daily_win_count": p.daily_win_count,
"fight": raw.encode("base64"),
"prototypeID": p.prototypeID,
"borderID": p.borderID,
"shutdown": shutdown}
for each in fight.player_team:
pet = p.pets[each.entityID]
if each.restHP == 0:
pet.daily_dead = True
else:
pet.daily_restHP = each.restHP
pet.save()
pet.sync()
else:
if not p.daily_rank:
PlayerDailyRankRanking.update_score(
p.entityID, p.daily_max_win_count)
# 自己连胜被终结
daily_win_count = int(self.pool.execute(
"GETSET", "daily_win_count_p{%d}" % p.entityID, 0) or 0)
# 死亡
self.pool.execute("SET", "daily_dead_p{%d}" % p.entityID, 1)
p.clear_daily_win_count()
# 奖励加成系数
multi = 0
daily_lose_config = get_config(DailyLoseConfig).get(
daily_win_count)
if not daily_lose_config and \
daily_win_count > max(get_config(DailyLoseConfig)):
daily_lose_config = get_config(
DailyLoseConfig)[max(get_config(DailyLoseConfig))]
if daily_lose_config:
self_shutdown_message = daily_lose_config.single_lose_desc
peer_shutdown_message = daily_lose_config.single_win_desc
full_shutdown_message = daily_lose_config.all_desc
# 取对手数据
data = g_entityManager.get_players_info(
[targetID], [
"entityID", "name", "daily_win_count",
"faction_name", "prototypeID", "borderID"])[0]
# 终结连胜
shutdown = target_win_count > 2
data.update({
"active": True, "shutdown": shutdown,
"win": fight.fightResult,
"fight": raw.encode("base64")
})
# 自己的战斗记录
p.daily_histories.appendleft(data)
p.daily_histories.ltrim(0, MAX_HIST_LEN - 1)
# 更新排名
p.daily_rank = PlayerDailyRankRanking.get_rank(p.entityID)
rewards = {}
reward = open_reward(
RewardType.DailyPVP, get_cons_value("DailyPVPDrop"))
rewards = reward.apply_after()
# 奖励加成
if multi:
for k, v in rewards.items():
if isinstance(v, int) and k != 'exp':
rewards[k] = int(v * (100 + multi) / float(100))
# 记录累计奖励
apply_reward(p, rewards, type=RewardType.DailyPVP)
combine_reward(rewards, [], data=p.daily_rewards)
p.daily_rewards = dict(p.daily_rewards)
p.daily_count += 1
p.daily_cache_targetID = 0
p.save()
p.sync()
# 添加直播
self.add_live({
"self_name": p.name,
"self_prototypeID": p.prototypeID,
"self_borderID": p.borderID,
"peer_name": data["name"],
"peer_prototypeID": data["prototypeID"],
"peer_borderID": data["borderID"],
"is_win": fight.fightResult,
}, top=p.daily_rank and p.daily_rank <= 5)
rsp.daily_win_count = p.daily_win_count
rsp.rewards = build_reward(rewards)
if self_message:
self_message = self_message.format(data["name"], p.daily_win_count)
g_redManager.send_red_message(
p, self_message, to_self=True, type=RedType.Normal)
if full_message:
full_message = full_message.format(
p.name, data["name"], p.daily_win_count)
_type = RedType.Horn if horn else RedType.Normal
g_redManager.send_red_message(
p, full_message, type=_type)
if red_count and red_message:
if daily_win_count == 1:
red_message = red_message.format(
p.name, red_count)
else:
red_message = red_message.format(
p.name, daily_win_count, red_count)
g_redManager.send_red_message(
p, red_message, red_drop=red_drop,
red_count=red_count, type=RedType.Red)
if full_shutdown_message:
if fight.fightResult:
full_shutdown_message = full_shutdown_message.format(
p.name, data["name"], target_win_count)
else:
full_shutdown_message = full_shutdown_message.format(
data["name"], p.name, daily_win_count)
_type = RedType.Horn if horn else RedType.Normal
g_redManager.send_red_message(
p, full_shutdown_message, type=_type)
if fight.fightResult:
if self_shutdown_message:
self_shutdown_message = self_shutdown_message.format(
data["name"], target_win_count)
g_redManager.send_red_message(
p.entityID, self_shutdown_message,
to_self=True, type=RedType.Normal)
if peer_shutdown_message:
peer_shutdown_message = peer_shutdown_message.format(
p.name, target_win_count)
g_redManager.send_red_message(
data["entityID"], peer_shutdown_message,
to_self=True, type=RedType.Normal)
else:
if self_shutdown_message:
self_shutdown_message = self_shutdown_message.format(
data["name"], daily_win_count)
g_redManager.send_red_message(
p.entityID, self_shutdown_message,
to_self=True, type=RedType.Normal)
if peer_shutdown_message:
peer_shutdown_message = peer_shutdown_message.format(
p.name, daily_win_count)
g_redManager.send_red_message(
data["entityID"], peer_shutdown_message,
to_self=True, type=RedType.Normal)
proxy.sync_daily_rank(targetID, history)
return rewards
def on_recharge(p, gold):
"""累计充值"""
flag = False
configs = get_config(AccRechargeConfig)
now = datetime.now()
now_ts = time.mktime(now.timetuple())
if g_campaignManager.daily_acc_recharge_campaign.is_open():
origin = p.daily_acc_recharge_amount
p.daily_acc_recharge_amount += gold
current = p.daily_acc_recharge_amount
reward_configs = g_campaignManager.\
daily_acc_recharge_campaign.get_reward_configs()
for each in reward_configs:
config = configs[each.ID]
if origin < config.gold and current >= config.gold:
p.daily_acc_recharge_rewards.add(each.ID)
flag = True
if g_campaignManager.cycle_acc_recharge_campaign.is_open():
origin = p.cycle_acc_recharge_amount
p.cycle_acc_recharge_amount += gold
current = p.cycle_acc_recharge_amount
reward_configs = g_campaignManager.\
cycle_acc_recharge_campaign.get_reward_configs()
for each in reward_configs:
config = configs[each.ID]
if origin < config.gold and current >= config.gold:
p.cycle_acc_recharge_rewards.add(each.ID)
p.cycle_acc_recharge_last_clean_time = now_ts
flag = True
if g_campaignManager.weeks_acc_recharge_campaign.is_open():
origin = p.weeks_acc_recharge_amount
p.weeks_acc_recharge_amount += gold
current = p.weeks_acc_recharge_amount
reward_configs = g_campaignManager.\
weeks_acc_recharge_campaign.get_reward_configs()
for each in reward_configs:
config = configs[each.ID]
if origin < config.gold and current >= config.gold:
p.weeks_acc_recharge_rewards.add(each.ID)
p.weeks_acc_recharge_last_clean_time = now_ts
flag = True
if g_campaignManager.month_acc_recharge_campaign.is_open():
origin = p.month_acc_recharge_amount
p.month_acc_recharge_amount += gold
current = p.month_acc_recharge_amount
reward_configs = g_campaignManager.\
month_acc_recharge_campaign.get_reward_configs()
for each in reward_configs:
config = configs[each.ID]
if origin < config.gold and current >= config.gold:
p.month_acc_recharge_rewards.add(each.ID)
p.month_acc_recharge_last_clean_time = now_ts
flag = True
if g_campaignManager.daily_recharge_campaign.is_open():
reward_configs = g_campaignManager.\
daily_recharge_campaign.get_reward_configs()
for config in reward_configs:
if gold == config.gold:
used = p.daily_recharge_useds.get(config.id, 0)
if used < config.count:
p.daily_recharge_useds[config.id] = used + 1
p.daily_recharge_rewards.append(config.id)
p.touch_daily_recharge_useds()
p.touch_daily_recharge_rewards()
break
if not p.monthly_card:
p.monthly_card_acc_amount += gold / 10
if p.monthly_card_acc_amount >= get_cons_value("MonthlyCardAccAmount"):
p.monthly_card_time = now
p.monthly_card_acc_amount = 0
p.monthly_card_received = False # 到期后同一日再次购买时重置
flag = True
if flag:
p.save()
p.sync()
def step_mazes(p, attr, incr, count):
mazes = get_config(MazeConfig)
maze_step_count = p.maze_step_count
results = []
while count > 0:
remain = time.time() + 3600
data = {}
config = mazes[maze_step_count % len(mazes)]
append = False # 是否加入事件组
attr["money_rest_pool"] = min(
attr.get("money_rest_pool", p.money_rest_pool) +
get_cons_value("MazeMustDropMoney"), p.money_most_pool)
attr["maze_rest_count"] = attr.get("maze_rest_count",
p.maze_rest_count)
data["attr"] = attr
data["incr"] = incr
if config.type == MazeEventType.DoubleMoney:
v = int(
attr.get("money_rest_pool", p.money_rest_pool) * config.argv)
v = max(min(v, p.money_most_pool), 0)
attr["money_rest_pool"] = v
elif config.type == MazeEventType.AddMoney:
v = int(
attr.get("money_rest_pool", p.money_rest_pool) + config.argv)
v = max(min(v, p.money_most_pool), 0)
attr["money_rest_pool"] = v
elif config.type == MazeEventType.DoubleCount:
origin = attr.get("maze_rest_count", p.maze_rest_count)
v = int(origin * config.argv)
v = max(v, 0)
if v > origin:
attr["maze_rest_count"] = origin
incr["maze_rest_count"] = incr.get("maze_rest_count",
0) + v - origin
else:
attr["maze_rest_count"] = v
elif config.type == MazeEventType.AddCount:
origin = attr.get("maze_rest_count", p.maze_rest_count)
v = int(origin + config.argv)
v = max(v, 0)
if v > origin:
attr["maze_rest_count"] = origin
incr["maze_rest_count"] = incr.get("maze_rest_count",
0) + v - origin
else:
attr["maze_rest_count"] = v
elif config.type == MazeEventType.Drop:
data.update({"drop": int(config.argv)})
elif config.type == MazeEventType.Shop:
if config.argv == MallType.Silver:
attr["mall_silver_open_remain"] = remain
elif config.argv == MallType.Golden:
attr["mall_golden_open_remain"] = remain
data.update({"argv": int(config.argv)})
append = True
elif config.type == MazeEventType.Case:
weights = []
for each in get_config(MazeCaseConfig):
if p.level >= each.level:
weights.append([each.drop, each.prob])
else:
break
drop = weighted_random2(weights)
data.update({"argv": int(drop)})
append = True
elif config.type == MazeEventType.Boss:
weights = []
for each in get_config(MazeBossConfig):
if p.level >= each.level:
weights.append([each.boss, each.prob])
else:
break
boss = weighted_random2(weights)
data.update({"argv": int(boss)})
append = True
elif config.type == MazeEventType.Noop:
pass
else:
break
result = {
"type": config.type,
"time": remain,
"append": append,
}
result.update(**data)
result.setdefault("argv", config.argv)
results.append(result)
attr["maze_rest_count"] = max(attr["maze_rest_count"] - 1, 0)
maze_step_count += 1
if "maze_rest_count" in attr and attr["maze_rest_count"] == 0:
break
if attr["money_rest_pool"] >= p.money_most_pool:
break
count -= 1
return results
def get_pvprankcount(update=False):
global RANK_COUNT
if RANK_COUNT is None or update:
with PlayerRankRanking.pool.ctx() as conn:
RANK_COUNT = conn.execute("ZCARD", PlayerRankRanking.key) or 0
return max(RANK_COUNT, get_cons_value("PvpMinRankerCount"))
def battle(self, p, fight, rsp):
mg = p.city_dungeon_mg_cache
message_configs = get_config(CityDungeonMessageConfig)
self_message = ""
message_config = message_configs.get(mg["id"])
if not message_config:
message_config = message_configs[max(message_configs)]
if fight.fightResult:
kills = len(mg.get("monsters", []))
config = self.get_mg_config_by_id(mg["id"])
rewards = parse_reward(config.rewards)
self_message = message_config.single_win_desc.format(mg["id"])
# 玩家损血
# {{ 使用每日PVP
for each in fight.player_team:
pet = p.pets[each.entityID]
if each.restHP == 0:
pet.daily_dead = True
else:
pet.daily_restHP = each.restHP
pet.save()
pet.sync()
# }}
else:
kills = 0
pending = []
for enemy in fight.enemy_team:
for m in mg["monsters"]:
if m["pos"] == enemy.posIndex:
if not enemy.restHP:
pending.append(m)
kills += 1
else:
m["restHP"] = enemy.restHP
for m in pending:
mg["monsters"].remove(m)
self.add_mg_into_pool(p, mg)
now = int(time.time())
# {{ 使用每日PVP
p.daily_dead_cd = now + get_cons_value("DailyDeadCD")
# }}
rewards = {}
self_message = message_config.single_lose_desc.format(mg["id"])
if fight.total_damage:
CityDungeonSelfRanking.incr_score(
p.entityID, fight.total_damage)
if kills:
self.incr_mg_kill(p, mg["id"], kills)
if fight.fightResult:
self.sync_city_dungeon_current_info(p)
if rewards:
rewards = combine_reward(
rewards, config.must_rewards)
rewards = apply_reward(
p, rewards, type=RewardType.CityDungeon)
build_reward_msg(rsp, rewards)
combine_reward(rewards, {}, p.city_dungeon_rewards)
if self_message:
g_redManager.send_red_message(
p, self_message, to_self=True,
module=RedModuleType.CityDungeon)
p.city_dungeon_mg_cache.clear()
p.save()
p.sync()
def battle(self, p, fight, rsp):
treasures = get_config(CityTreasureConfig)
self_message = ""
full_message = ""
red_message = ""
red_count = 0
horn = False
target = p.city_contend_cache_target
if self.is_top_faction(p.factionID):
message_configs = get_config(CityContendDefendMessageConfig)
message_config = message_configs.get(p.city_contend_count)
if not message_config:
message_config = message_configs[max(message_configs)]
if fight.fightResult:
event = self.get_current_step(p)
drop = event["argv"]
reward = open_reward(RewardType.CityContendDefend, drop)
rewards = reward.apply(p)
combine_reward(rewards, {}, p.city_contend_rewards)
try:
target_name = target.get("name", u"").decode("utf-8")
target_faction_name = (target.get(
"faction_name", u"") or u"").decode("utf-8")
except UnicodeEncodeError:
target_name = target.get("name", u"")
target_faction_name = target.get("faction_name", u"")
self_message = message_config.single_defend_win_desc.format(
target_faction_name, target_name
)
# {{ 使用每日PVP
for each in fight.player_team:
pet = p.pets[each.entityID]
if each.restHP == 0:
pet.daily_dead = True
else:
pet.daily_restHP = each.restHP
pet.save()
pet.sync()
# }}
rsp.rewards = build_reward(rewards)
else:
sub = p.city_contend_treasure * get_cons_value(
"CityContendFailPunish") / float(100)
p.city_contend_treasure = max(
p.city_contend_treasure - sub, 1)
# {{ 每日PVP
now = int(time.time())
p.daily_dead_cd = now + get_cons_value("DailyDeadCD")
# }}
try:
target_name = target.get("name", u"").decode("utf-8")
target_faction_name = (target.get(
"faction_name", u"") or u"").decode("utf-8")
except UnicodeEncodeError:
target_name = target.get("name", u"")
target_faction_name = target.get("faction_name", u"")
self_message = message_config.single_defend_lose_desc.format(
target_faction_name, target_name
)
module = RedModuleType.CityContendDefend
else:
message_configs = get_config(CityContendAttackMessageConfig)
message_config = message_configs.get(p.city_contend_count + 1)
if not message_config:
message_config = message_configs[max(message_configs)]
if fight.fightResult:
p.city_contend_count += 1
self_count = CityContendAttackRanking.update_score(
p.entityID, p.city_contend_count)
count = CityContendAttackRanking.pool.execute(
"ZCOUNT", CityContendAttackRanking.key, self_count, "+inf")
CityContendFactionRanking.incr_score(
p.factionID, 1)
treasure = treasures.get(
p.city_contend_cache_target.get("level", 1))
if not treasure:
treasure = treasures[max(treasures)]
money = treasure.attack_treasure * get_cons_value(
"CityContendAttackMoney")
soul = treasure.attack_treasure * get_cons_value(
"CityContendAttackSoul")
event = self.get_current_step(p)
drop = event["argv"]
gain = {"money": money, "soul": soul}
reward = open_reward(
RewardType.CityContendAttack, drop
)
drop_reward = reward.apply_after()
total_reward = apply_reward(
p, combine_reward(gain, drop_reward),
type=RewardType.CityContendAttack)
combine_reward(total_reward, {}, p.city_contend_rewards)
p.city_contend_total_treasure += treasure.attack_treasure
rsp.rewards = build_reward(drop_reward)
rsp.treasure_rewards = build_reward(gain)
rsp.treasure_count = treasure.attack_treasure
if not message_config.multiple1 or message_config.multiple1 \
and count == 1:
full_message = message_config.attack_count_desc.format(
p.faction_name, p.name, p.city_contend_count
)
horn = message_config.horn1
try:
target_name = target.get("name", u"").decode("utf-8")
except UnicodeEncodeError:
target_name = target.get("name", u"")
self_message = message_config.single_attack_win_desc.format(
target_name
)
if not message_config.multiple2 or message_config.multiple2 \
and count == 1:
red_count = message_config.red_paper_count
red_drop = message_config.red_paper
red_message = message_config.red_paper_desc.format(
p.faction_name, p.name,
p.city_contend_count, red_count
)
# {{ 使用每日PVP
for each in fight.player_team:
pet = p.pets[each.entityID]
if each.restHP == 0:
pet.daily_dead = True
else:
pet.daily_restHP = each.restHP
pet.save()
pet.sync()
# }}
else:
# {{ 每日PVP
now = int(time.time())
p.daily_dead_cd = now + get_cons_value("DailyDeadCD")
# }}
# FIXME
try:
target_name = target.get("name", u"").decode("utf-8")
except UnicodeEncodeError:
target_name = target.get("name", u"")
self_message = message_config.single_attack_lose_desc.format(
target_name
)
module = RedModuleType.CityContendAttack
if self_message:
g_redManager.send_red_message(
p, self_message,
to_self=True,
module=module)
if full_message:
_type = RedType.Horn if horn else RedType.Normal
g_redManager.send_red_message(
p, full_message, type=_type,
module=module)
if red_message and red_count:
g_redManager.send_red_message(
p, red_message, red_drop=red_drop,
red_count=red_count, type=RedType.Red,
module=module)
p.save()
p.sync()
def get_bought_fund_count():
"""开服基金购买人数"""
with pool.ctx() as conn:
return int(conn.execute("GET", FUND_BOUGHT_COUNT) or 0) +\
get_cons_value("FundFakeNumber")
