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 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 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, 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 kick_group_member_offline(entityID, groupID):
rs = quit_group(entityID, groupID)
dt = datetime.now()
g = Group.simple_load(groupID, ["name"])
title, content, ID = get_mail("GroupKick")
send_mail(entityID,
title,
content.format(dt.strftime(DATETIMEFMT), g.name),
configID=ID)
return rs
def kick_group_member(entityID, groupID):
rs = quit_group(entityID, groupID)
dt = datetime.now()
g = Group.simple_load(groupID, ["name"])
title, content, ID = get_mail("GroupKick")
send_mail(entityID,
title,
content.format(dt.strftime(DATETIMEFMT), g.name),
configID=ID)
p = g_entityManager.get_player(entityID)
if p:
p.sync()
return rs
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 invite_friend_offline(friendID, friendfbID, name, fbname):
field = "friendfb_list"
encode = Player.fields[field].encoder or (lambda s: s)
key = "_".join([field, "p{%d}" % friendID])
if not Player.pool.execute("HSET", key, encode(friendfbID), ""):
False
title, content, ID = get_mail("FriendInvite")
do_send_mail(
friendID,
title,
content.format(name, fbname),
cd=FRIENDFB_INTERVAL, configID=ID)
join_friendfb(friendfbID, friendID)
return True
def invite_group_member_offline(entityID, groupID, name):
now = int(time.time())
g = Group.simple_load(groupID, ["invites", "gve_last_kick_time"])
if now < g.gve_last_kick_time + ONE_DAY:
return msgTips.FAIL_MSG_GROUP_KICK_TOO_FREQUENTLY_TO_INVITED
g.invites.load()
if entityID in g.invites:
return msgTips.FAIL_MSG_GROUP_ALREADY_INVITED # 已经邀请过了
title, content, ID = get_mail("GroupInvite")
send_mail(entityID,
title,
content.format(name, groupID),
cd=ONE_DAY,
configID=ID)
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 invite_friend(friendID, friendfbID, name, fbname):
f = g_entityManager.get_player(friendID)
if friendfbID in f.friendfb_list:
return False
title, content, ID = get_mail("FriendInvite")
do_send_mail(
friendID,
title,
content.format(name, fbname),
cd=FRIENDFB_INTERVAL, configID=ID)
f.friendfb_list.add(friendfbID)
join_friendfb(friendfbID, friendID)
f.save()
f.sync()
return True
def kick_member_failure(factionID, entityID):
faction = Faction.simple_load(factionID, ['name', 'memberset'])
player = Player.simple_load(entityID,
['factionID', 'joinFactionTime', 'mailset'])
if player.factionID == factionID:
now = int(time.time())
if player.joinFactionTime and \
(now - player.joinFactionTime) < QUITFACTIONCD:
return msgTips.FAIL_MSG_FACTION_CAN_NOT_LEAVE
clean_faction(player.entityID)
faction.save()
dt = datetime.fromtimestamp(now).strftime("%Y-%m-%d %H:%M:%S")
title, content, ID = get_mail("FactionKick")
send_mail(entityID,
title,
content.format(dt, faction.name),
configID=ID)
return SUCCESS
return msgTips.FAIL_MSG_FACTION_MEMBER_ALREADY_QUIT
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 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
def gift_friend(friendID, name, rewards):
title, content, ID = get_mail("FriendGift")
do_send_mail(
friendID, title,
content.format(name), addition=rewards, configID=ID)
return True
