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_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 city_send_mail_offline(entityID, title, content, rewards, key, ID):
if not int(Player.pool.execute(
"HSET", "city_rewards_recv_p{%d}" % entityID, key, "") or 0):
return
p = Player.simple_load(entityID, ['factionID'])
rank = CityDungeonKillRanking.get_rank(p.factionID)
content = content.format(rank)
send_mail(entityID, title, content, addition=rewards, configID=ID)
def ranking_send_mail_offline(entityID, title, content, rewards, key, ID):
p = Player.simple_load(entityID, ["rankingreceiveds"])
if p:
if key in p.rankingreceiveds:
return
if not int(
Player.pool.execute("HSET", "ranking_receiveds_p{%d}" % entityID,
key, "") or 0):
return
send_mail(entityID, title, content, addition=rewards, configID=ID)
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 send_mail(self, player, title, content, rewards, key, ID):
if key in player.pvprankreceiveds:
return
send_mail(player.entityID,
title,
content,
addition=rewards,
configID=ID,
type=MailType.Pvp)
player.pvprankreceiveds.add(key) # 防止重复添加
player.save()
player.sync()
def givegoldmail(player):
import time
from config.configs import get_config, GiveGoldConfig
from mail.manager import send_mail
config = get_config(GiveGoldConfig)[0]
now = int(time.time())
if config.start <= now and now < config.end:
if config.rewards:
send_mail(
player.entityID,
config.title,
config.desc,
addition=parse_reward(config.rewards))
def ranking_send_mail(entityID, title, content, rewards, key, ID):
if not int(
Player.pool.execute("HSET", "ranking_receiveds_p{%d}" % entityID,
key, "") or 0):
return
p = g_entityManager.get_player(entityID)
if p:
if key in p.rankingreceiveds:
return
p.ranking_receiveds.load()
send_mail(p.entityID, title, content, addition=rewards, configID=ID)
p.save()
p.sync()
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 add_mail(key):
title = request.POST.getone("title", "")
content = request.POST.getone("content", "")
petList = validate_list(request.POST.getone("petList", ""))
matList = validate_list(request.POST.getone("matList", ""))
equipList = validate_list(request.POST.getone("equipList", ""))
specPacks = validate_list(request.POST.getone("specpackList", ""))
specPacks = specPacks or validate_list(request.POST.getone(
"specPacks", ""))
gemList = validate_list(request.POST.getone("gemList", ""))
entityID = int(request.POST.getone('entityID') or 0)
reward = {}
from reward.base import get_reward_attr_list
for attr in get_reward_attr_list():
value = int(request.POST.getone(attr) or 0)
if value:
reward[attr] = value
if petList:
from config.configs import get_config, PetConfig
for id, count in petList:
if id not in get_config(PetConfig):
return json.dumps('failure')
reward['petList'] = petList
if matList:
from config.configs import get_config, MatConfig
for id, count in matList:
if id not in get_config(MatConfig):
return json.dumps('failure')
reward['matList'] = matList
if equipList:
from config.configs import get_config, NewEquipConfig
for id, count in equipList:
if id not in get_config(NewEquipConfig):
return json.dumps("failure")
reward['equipList'] = equipList
if specPacks:
from config.configs import get_config, SpecpackConfig
for id, count in specPacks:
if id not in get_config(SpecpackConfig):
return json.dumps('failure')
reward['specPacks'] = specPacks
if gemList:
from config.configs import get_config, GemConfig
for id, count in gemList:
if id not in get_config(GemConfig):
return json.dumps('failure')
reward['gemList'] = gemList
cd = 30 * 24 * 60 * 60
from mail.manager import send_mail
send_mail(entityID, title, content, addition=reward, cd=cd)
return SUCCESS
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 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_mail(self, player, title, content, rewards, grad, key):
if key in player.pvprankreceiveds:
return
send_mail(player.entityID,
title,
content,
addition=rewards,
type=MailType.Pvp)
player.pvpseasonreward = {
"title": title,
"reward": rewards,
"grad": grad
}
player.pvprankreceiveds.add(key) # 防止重复添加
player.save()
player.sync()
def give():
slevel, elevel, fbID, title, content, reward, value = get_give_arguments(
request.POST)
reward = {reward: value}
from entity.manager import g_entityManager
from mail.manager import send_mail
from mail.manager import validate_mail_condition
for player in g_entityManager.players.values():
if not validate_mail_condition(player, {
'slevel': slevel,
'elevel': elevel,
'fbID': fbID
}):
continue
send_mail(player.entityID, title, content, addition=reward)
return SUCCESS
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_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 load_player(
self,
userID,
entityID,
clientVersion='',
featureCode='',
clientIP=''):
from reward.manager import givegoldmail
player = self.get_player(entityID)
if player:
return player
user = User.get(userID)
# 校验entityID
if not user or entityID not in user.roles.get(settings.REGION['ID']):
logger.error('player crossed failed %d', entityID)
return
player = Player.load(entityID)
player.userID = user.userID
player.username = user.username
player.username_alias = user.username_alias or ''
player.channel = user.channel or ''
if not player:
return
self.set_player(player)
if not player.lastlogin:
create_player(player)
player.totallogin = 1 # 累计登陆
player.seriallogin = 1 # 连续登陆
givegoldmail(player)
player.clientVersion = clientVersion
player.featureCode = featureCode
player.clientIP = clientIP
from common.log import role_register
role_register.info(player=player)
if not user.back_reward_received:
data = get_player_reward()
try:
gold, credits = data[user.username]
except KeyError:
pass
else:
from mail.manager import send_mail
send_mail(
player.entityID, u'老训练师钻石大礼',
u' 亲爱的训练师，您好！这是您在《神奇小精灵》充值所获得钻石的返还，请查收！',
addition={'gold': gold})
player.credits = credits
user.back_reward_received = True
user.save()
else:
player.load_pets()
player.load_equips()
player.load_mails()
player.load_faction()
player.load_group()
player.load_offline_attrs()
# player.load_offline_mail()
today = datedate.today()
if player.lastlogin.date() != today: # 当日重复不计算累计连续登陆
# 永久商店还没开启的情况下每天都要清空玩家身上商品信息
# 目的是临时商店开启时第一次有效地刷新商品信息
clean_yesterday_daily_taskrewards(player) # 策划要求，隔天的任务奖励全部清空
if player.lastlogin.date() < (
datedate.today() -
timedelta(
days=1)): # 昨天没登陆
player.seriallogin = 1
if player.guide_end_signal:
player.seriallogin_after_guide = 1
else:
player.seriallogin += 1
if player.guide_end_signal:
player.seriallogin_after_guide += 1
player.totallogin += 1
if player.guide_end_signal:
player.totallogin_after_guide += 1
player.get_serialloginreward = 0
# 月卡减去每天登录的天数
if player.monthly_card_30:
delta = today - player.lastlogin.date()
player.monthly_card_30 = max(
player.monthly_card_30 - delta.days + 1, 0)
# {{ 新月卡
if player.monthcard1:
delta = today - player.lastlogin.date()
player.monthcard1 = max(
player.monthcard1 - delta.days + 1, 0)
if player.monthcard2:
delta = today - player.lastlogin.date()
player.monthcard2 = max(
player.monthcard2 - delta.days + 1, 0)
if player.weekscard1:
delta = today - player.lastlogin.date()
player.weekscard1 = max(
player.weekscard1 - delta.days + 1, 0)
if player.weekscard2:
delta = today - player.lastlogin.date()
player.weekscard2 = max(
player.weekscard2 - delta.days + 1, 0)
# }}
# build_loginreward_set(player)
givegoldmail(player)
# 控制日冒险礼包
if player.trigger_packs_flag:
player.trigger_packs_flag = getattr(
settings, "TRIGGER_PACKS_FLAG", True)
from pvp.rank import g_rankManager
g_rankManager.check_mail(player)
g_rankManager.reset_rank(player)
from pvp.swap import g_swapManager
g_swapManager.give_rewards(player)
from campaign.manager import g_campaignManager
g_campaignManager.reset(player)
from pvp.daily import g_dailyManager
g_dailyManager.reset(player)
from faction.city import g_cityDungeon
g_cityDungeon.reset_player(player, all=True)
from faction.city import g_cityContend
g_cityContend.reset_player(player, all=True)
from campaign.manager import reset_check_in_monthly
reset_check_in_monthly(player)
from pvp.rob import check_rob, resize_rob_history_by_time
check_rob(player)
from pvp.loot import check_loot
check_loot(player)
resize_rob_history_by_time(player)
from campaign.manager import start_count_down
start_count_down(player)
from mall.manager import reset_vip_packs
reset_vip_packs(player)
from mall.manager import first_recharge_patch
first_recharge_patch(player)
from campaign.manager import reset_fund
reset_fund(player)
from explore.dlc import g_dlcCampaignManager
g_dlcCampaignManager.reset_task(player)
from group.manager import give_reward_by_mail
give_reward_by_mail(player)
from explore.boss import give_reward
give_reward(player)
from world.service import give_goods
configs = get_config(RechargeConfig)
# from task.manager import patch_noob_tasks
# patch_noob_tasks(player)
# patch_guide_fb(player)
for g, amount in player.offline_recharges or []:
config = configs.get(g)
if config:
give_goods(player, config, amount=amount)
player.offline_recharges = []
from explore.ambition import reload_ambition
reload_ambition(player)
from explore.ambition import reload_vip_ambition
reload_vip_ambition(player)
from task.manager import on_monthly_card
on_monthly_card(player)
from task.manager import on_vip_level
on_vip_level(player)
from task.manager import on_login
on_login(player)
from task.manager import on_vip_level
on_vip_level(player)
from task.manager import on_levelup
on_levelup(player)
from task.manager import on_dlc_score
on_dlc_score(player)
from task.manager import on_friends_count
on_friends_count(player)
from campaign.manager import reset_online_packs
reset_online_packs(player, refresh=True)
from campaign.manager import reset_consume_campaign
reset_consume_campaign(player)
from campaign.manager import reset_login_campaign
reset_login_campaign(player)
from mail.manager import apply_condition_mail
apply_condition_mail(player)
from campaign.manager import do_login_campaign
do_login_campaign(player)
from campaign.manager import reset_recharges
reset_recharges(player)
check_power_packs(player)
player.daily_first_login = True
now = int(time.time())
player.lastlogin = datetime.fromtimestamp(now)
# 推荐好友
from friend.manager import recommendp
recommendp(player)
if player.first_recharge_flag:
player.first_recharge_flag = getattr(
settings, "PAY", True)
# 触发power计算， 更新indexing
if not user.back_level_reward_received:
data = get_player_level_reward()
try:
level, gold = data[user.username]
except KeyError:
pass
else:
from mail.manager import send_mail
send_mail(
player.entityID, u'老训练师等级返利',
u'亲爱的训练师： 您在旧版《神奇小精灵》1月17日之前，达到[colorF:246;255;0]%d级[colorF:255;255;255]，向您奉上[colorF:246;255;0]钻石*%d[colorF:255;255;255]。祝您游戏愉快～' % (level, gold),
addition={'gold': gold})
user.back_level_reward_received = True
user.save()
# update seed state
from campaign.manager import g_campaignManager
if g_campaignManager.seed_campaign.is_open():
g_campaignManager.seed_campaign.updateSeedState(player)
# player.update_power()
player.save()
return player
