def pvpEnemyData(request, response):
'''
敌军 详细数据
'''
player = request.player
target_player_id = getattr(request.logic_request, "userId", 0)
target_player = get_player(target_player_id, False)
if not target_player:
raise ErrorException(
player,
u"pvpEnemyData:pvp army layout target player is None:target player id(%s) is not existed"
% target_player_id)
all_heros = target_player.layoutSiegeHeroes
artifacts_view_list = []
equips_view_list = []
hero_view_list = []
for hero in all_heros:
hero_view_list.append(hero.to_dict())
all_hero_equips = get_playerheroes_equips(target_player, [hero])
for equip in all_hero_equips:
equips_view_list.append(equip.to_dict())
all_hero_artifacts = get_playerheroes_artifacts(target_player, [hero])
for artifact in all_hero_artifacts:
artifacts_view_list.append(artifact.to_dict())
response.logic_response.set("artifacts", artifacts_view_list)
response.logic_response.set("equips", equips_view_list)
response.logic_response.set("heros", hero_view_list)
response.logic_response.set("user", target_player.userSimple_dict())
return response
def siegeBattlePlayerLock(request, response):
"""
攻城战对手锁定 or 解锁
"""
player = request.player
oppId = getattr(request.logic_request, "oppId", 0)
isLocked = True
# 检查等级
if not player.isOpenSiege:
AlertHandler(
player, response, AlertID.ALERT_PLAYER_LEVEL_NOT_ENOUGH,
u"siegeBattlePlayerLock:need level(%s) player level is %s" %
(Static.SIEGE_LEVEL, player.level))
return response
for _index, _opp in enumerate(player.SiegeBattle.opps):
_player = get_player(_opp["player_id"], False)
if _opp["player_id"] == oppId:
player.SiegeBattle.opps[_index]["isLocked"] = not _opp["isLocked"]
player.SiegeBattle.update()
isLocked = player.SiegeBattle.opps[_index]["isLocked"]
break
response.logic_response.set("isLocked", isLocked)
response.common_response.player.set("siegeBattle",
player.SiegeBattle.to_dict())
return response
def pvpRank(request, response):
'''
PVP世界排名
'''
player = request.player
now = datetime.datetime.now()
week = now.isoweekday()
hour = now.hour
# 这个字段表明 是否需要上周的数据
last_rank = False
# 如果当前是不允许ｐｖｐ战斗的时间，取得的数据上周的排行。
if week == Static.PVP_STOP_WEEK and hour < Static.PVP_STOP_HOUR:
last_rank = True
rank_datas = PVPRank.get_last_ranks()
else:
rank_datas = PVPRank.get_ranks()
opp_data = []
for p_id, p_score in rank_datas:
if not p_id or p_id == "None":
continue
if p_score >= Static.PVP_INIT_SCORE:
opp_player = get_player(p_id, False)
if opp_player and opp_player.level >= Static.PVP_LEVEL:
dicts = opp_player.pvp_view_data(can_fight=True,
last_rank=last_rank)
opp_data.append(dicts)
response.logic_response.set("rankOpps", opp_data)
return response
def to_SimpleDict(self):
dicts = {}
from module.player.api import get_player
members = [get_player(pk, False) for pk in self.membersIds]
dicts["powerRank"] = reduce(lambda x, y: x + y,
[player.powerRank for player in members])
dicts["name"] = self.name
dicts["level"] = self.level
dicts["icon"] = self.icon
dicts["limitLevel"] = self.limitLevel
dicts["powerRank"] = self.powerrank
dicts["outerAttention"] = self.outerAttention
dicts["category"] = self.category
dicts["id"] = self.pk
chairman = get_player(self.chairmanId, False)
dicts["members"] = [
chairman.guild.userGuild_dict(chairman.guild.guildInfo)
] #所有时候只需要公会会长信息
dicts["memberCount"] = len(self.membersIds)
dicts["requestMemberIds"] = self.requestMemberIds
return dicts
def run(self):
ThreadPoolCounter.increase() # スレッドカウンタインクリメント
user_agent = get_random_user_agent(self.random_unique_id)
opensocial_userid = create_hashed_debug_user_id(user_agent)
# print opensocial_userid
player = get_player(opensocial_userid)
# チュートリアルは強制的に完了
# if not player.is_end_tutorial():
# player.end_tutorial()
# view_url = reverse('mobile_quest_index')
# request_send(user_agent, self.site_domain, view_url)
request_controller = AppRequestController(user_agent, self.site_domain, player)
request_controller.random_execute()
ThreadPoolCounter.decrease() # スレッドカウンタデクリメント
def guildKickMembers(request, response):
"""
社团踢人
"""
player = request.player
targetPlayerId = getattr(request.logic_request, "targetPlayerId", 0)
targetPlayer = get_player(targetPlayerId)
# 不能踢出所选的人因为权限不够
if player.guild.position >= targetPlayer.guild.position:
targetPlayer.self_release_lock()
AlertHandler(
player, response, AlertID.ALERT_GUILD_LIMIT_CAN_NOT_KICK_MEMBERS,
u"guildKickMembers your position is %s targert position is %s " %
(player.guild.position, targetPlayer.guild.position))
return response
if player.guildId != targetPlayer.guildId:
targetPlayer.self_release_lock()
return response
player.guild.kick_from_guild(targetPlayer)
# # 把训练所里的英雄信息更新
# if targetPlayer.trainingHeroIds:
# for hero_id in targetPlayer.trainingHeroIds:
# hero = targetPlayer.heroes.get(hero_id)
# hero.quiteHeroFromGuild()
# targetPlayer.heroes.update(hero, True)
# # 把自己有关公会的信息更新
# targetPlayer.quiteGuild()
# 创建一条日志
create_loginfo(player.guildId, 2, targetPlayer.name)
# info = make_guildInfo(new_guild)
# response.logic_response.set("info", info)
# response.common_response.player.set("trainingHeroIds", player.trainingHeroIds)
response.common_response.player.set("guild", player.guild.to_dict())
return response
def get_unFighting_member_info(self):
from player.api import get_player
playerInfoDict = {}
pid_list = self.get_unFighting_member_list()
for player_id in pid_list:
feiBook = 0 #未发飞鸽传书
_player = get_player(player_id, lock=False)
if str(player_id) not in playerInfoDict:
if str(player_id) in self.guildInfo.feiBookDict:
feiBook = 1
playerInfoDict[str(player_id)] = {
"feiBook": feiBook,
"name": _player.name,
"level": _player.level,
"iconId": _player.iconId
}
self.self_release_lock()
return playerInfoDict
def guild_siegebattle_reward(playerId, rewards):
"""
公会团战个人奖励
"""
from module.player.api import get_player
player = get_player(playerId)
config = get_guildsiegeconfiginfo_by_playerid(playerId)
if not player or not config:
return []
#个人战斗力
power = config.allPower
#总战斗力
powerRank = get_guildsiege_allpower(player.guildId)
personal_reward = []
for reward in rewards:
count = round( power/float(powerRank),2) * reward.count
_reward = CommonReward(reward.type, count, reward.level)
personal_reward.append(_reward)
return personal_reward
def displayAppMember(request, response):
"""
展示申请加入的人员信息
"""
player = request.player
guildInfo = player.guild.guildInfo
membersInfo = []
# 如果在等待审核期间，发出申请的人已经加入别的社团那么就不展示他的信息。直接删掉
for _playerId in guildInfo.requestMemberIds:
_player = get_player(_playerId, False)
if _player.guildId:
player.guild.disallow_join_guild(_playerId) #已经加入其它公会
#guildInfo.requestMemberIds.remove(_playerId)
else:
membersInfo.append(_player.guild.userGuild_dict(guildInfo))
guildInfo.save()
response.logic_response.set("members", membersInfo)
return response
def guildPositionUp(request, response):
"""
职位变更
"""
player = request.player
category = getattr(request.logic_request, "category", 0)
targetPlayerId = getattr(request.logic_request, "id", 0)
targetPlayer = get_player(targetPlayerId)
if not player.guild.isChairman:
targetPlayer.self_release_lock()
AlertHandler(
player, response,
AlertID.ALERT_GUILD_LIMIT_NOT_ENOUGH_TO_POSITION_UP,
u"guildPositionUp your position is %s targert position is %s " %
(player.guild.posiotn, targetPlayer.guild.position))
return response
guildInfo = player.guild.guildInfo
# 升职。管理员给普通会员升职为副会长
if category == 1:
guildLevel = get_guild(guildInfo.level)
#传职
if targetPlayer.pk in guildInfo.viChairmanIds:
player.guild.exchange_position(targetPlayer)
create_loginfo(player.guildId, 3, player.name)
create_loginfo(player.guildId, 5, targetPlayer.name)
#会员变为副会长
else:
if guildInfo.viChairmanCount >= guildLevel.viceChairmanCount:
targetPlayer.self_release_lock()
guildInfo.self_release_lock()
AlertHandler(
player, response,
AlertID.ALERT_GUILD_VICHAIRMAN_COUNT_HAS_TOP,
u"guildPositionUp guild is level %s can has %s vichairmans now is %s "
% (guildInfo.level, guildLevel.viceChairmanCount,
guildInfo.viChairmanCount))
return response
player.guild.change_position(targetPlayer,
Static.GUILD_VI_CHAIRMAN_POSITION)
create_loginfo(player.guildId, 3, targetPlayer.name)
# 降职
elif category == 2:
if not targetPlayer.guild.isViChairman:
targetPlayer.self_release_lock()
guildInfo.self_release_lock()
return response
player.guild.change_position(targetPlayer,
Static.GUILD_NORMAL_POSITION)
create_loginfo(player.guildId, 4, targetPlayer.name)
else:
targetPlayer.self_release_lock()
guildInfo.self_release_lock()
response.common_response.player.set("guild", player.guild.to_dict())
return response
def targetPlayer(self):
from module.player.api import get_player
targetPlayer = get_player(self.targetPlayerId, False)
return targetPlayer
def powerRank(self):
from module.player.api import get_player
return reduce(
lambda x, y: x + y,
[get_player(pk, False).powerRank for pk in self.membersIds])
def speedUpHero(request, response):
"""
为社团成员加速
"""
player = request.player
targetPlayerId = getattr(request.logic_request, "targetPlayerId", 0)
category = getattr(request.logic_request, "category", 0)
# 每人每天的加速和被加速的次数是有限制的
# if player.speedCount <= 0:
# AlertHandler(player, response, AlertID.ALERT_PLAYER_HAS_NO_SPEEDING_COUNT, u"speedUpHero PLAYER has no speeding count %s" %player.id)
# return response
#每日最多加速5次
if player.guild.isMaxSpeed:
response.common_response.player.set("guild", player.guild.to_dict())
return response
targetPlayer = None
if targetPlayerId:
if targetPlayerId == player.id:
return response
targetPlayer = get_player(targetPlayerId)
if not targetPlayer:
return response
#不在公会
if targetPlayerId not in player.guild.guildInfo.membersIds:
player.guild.guildInfo.self_release_lock()
targetPlayer.self_release_lock()
response.common_response.player.set("guild",
player.guild.to_dict(True))
return response
#modify by ljdong 同一个用户可以被多次加速
#if targetPlayerId in player.guild.speedPlayerIds:
#response.common_response.player.set("guild", player.guild.to_dict(True))
#return response
#每日最多被加速5次
if targetPlayer.guild.isMaxSpeeded:
player.guild.guildInfo.self_release_lock()
targetPlayer.self_release_lock()
response.common_response.player.set("guild",
player.guild.to_dict(True))
return response
else:
memberIds = copy.copy(player.guild.guildInfo.membersIds)
random.shuffle(memberIds)
for memberId in memberIds:
#modify by ljdong
#if memberId in player.guild.speedPlayerIds:
#continue
if memberId == player.id:
continue
targetPlayer = get_player(memberId)
#每日最多被加速5次
if targetPlayer.guild.isMaxSpeeded:
targetPlayer.self_release_lock()
continue
targetPlayerId = memberId
break
if not targetPlayerId:
return response
guildLevel = get_guild(player.guild.guildInfo.level)
player.guild.speed(targetPlayer)
contents = []
contents.append({
"content":
"fytext_301171",
"paramList": [player.guild.guildInfo.name, targetPlayer.name],
})
send_system_mail(player,
None,
"fytext_301173",
contents=contents,
rewards=guildLevel.speedRewards)
contents = []
contents.append({
"content": "fytext_301172",
"paramList": [player.guild.guildInfo.name, player.name],
})
send_system_mail(targetPlayer,
None,
"fytext_301173",
contents=contents,
rewards=guildLevel.speedRewards)
response.common_response.player.set("guild", player.guild.to_dict())
return response
def _siegeBattleResult(request, response):
"""
攻城战结算
"""
player = request.player
isWin = getattr(request.logic_request, "isWin", False)
soldiers = getattr(request.logic_request, "soldiers", [])
targetId = getattr(request.logic_request, "oppId", False)
if not player.isOpenSiege:
AlertHandler(
player, response, AlertID.ALERT_LEVEL_SHORTAGE,
u"_siegeBattleResult:playerLevel(%s) startLevel(%s)" %
(player.level, Static.SIEGE_LEVEL))
return response
# 目标玩家
if int(targetId) != int(player.SiegeBattle.oppId):
# 检验目标
raise ErrorException(
player,
u"siegeBattleResult: SiegeBattle target player is not correct:target player id(%s) is not existed"
% targetId)
# 记录本次对战结果
player.SiegeBattle.fightEnd(isWin)
target_player = get_player(targetId)
print '目标ＩＤ', targetId
resource = {}
if isWin:
# 掠夺的资源
if targetId > 0:
# 真人
resource = target_player.SiegeBattle.get_resources_settlement()
target_player.siege_be_ended() # 清空攻击时间
# 隐藏分变化
player.add_liveness(18)
target_player.sub_liveness(15)
# 防守失败者有3小时的受保护时间
print '设置保护时间3小时'
target_player.set_lock_time()
else:
# 机器人
resource = get_robot_resource(targetId)
player.add_liveness(12)
player.SiegeBattle.add_resource(resource)
else:
# 隐藏分变化
if targetId > 0:
player.add_liveness(6)
target_player.sub_liveness(5)
target_player.siege_be_ended() # 清空攻击时间
else:
player.add_liveness(4)
player.cancel_protect_time()
# 将资源转化成奖励
rewards = player.SiegeBattle.from_resource_to_reward(resource)
send_battle_record(player=player,
targetPlayer=target_player,
isWin=isWin,
category=2,
playerHeroes=player.layoutSiegeHeroSimple_dict(),
targetHeroes=target_player.layoutSiegeHeroSimple_dict(),
playerWallSoldiers=soldiers,
targetWallSoldiers=target_player.siege_wall_soldiers(),
resource=resource)
if target_player.id > 0:
send_battle_record(
player=target_player,
targetPlayer=player,
isWin=not isWin,
category=2,
playerHeroes=target_player.layoutSiegeHeroSimple_dict(),
targetHeroes=player.layoutSiegeHeroSimple_dict(),
playerWallSoldiers=target_player.siege_wall_soldiers(),
targetWallSoldiers=soldiers,
resource=resource)
player.dailytask_going(Static.DAILYTASK_CATEGORY_SIEGE_BATTLE,
number=1,
is_incr=True,
is_series=True)
player.SiegeBattle.update()
response.logic_response.set("rewards",
[reward.to_dict() for reward in rewards])
response.common_response.player.set("siegeBattle",
player.SiegeBattle.to_dict())
return response
def to_dict(self, is_all=False, is_root=False):
dicts = super(SysGuildInfo, self).to_dict(is_all)
from module.player.api import get_player
if is_all:
dicts["idStr"] = self.idStr
today = datetime.datetime.now().date()
if self.contributeAt.date() != today:
dicts["dailyXp"] = 0
if not is_root and (is_all or
("membersIds" in self.mKeys or "viChairmanIds"
in self.mKeys or "chairmanId" in self.mKeys)):
members = [get_player(pk, False) for pk in self.membersIds]
dicts["powerRank"] = reduce(
lambda x, y: x + y, [_player.powerRank for _player in members])
dicts["members"] = [
_player.guild.userGuild_dict(self) for _player in members
]
if len(dicts["mKeys"]) > 0:
dicts["mKeys"].append("powerRank")
dicts["mKeys"].append("members")
self.powerrank = dicts["powerRank"]
self.save()
#必须放在最后处理
del_keys = ["attentionV", "membersIds", "contributeAt"]
for del_key in del_keys:
if del_key in dicts:
del dicts[del_key]
if del_key in dicts["mKeys"]:
dicts["mKeys"].remove(del_key)
now = int(time.time())
if "fire1" in dicts:
if dicts["fire1"]["status"] == 2:
dicts["fire1"]["timeLeft"] = dicts["fire1"][
"fireAt"] + 3600 * dicts["fire1"]["fireHour"] + 1
if dicts["fire1"]["status"] == 1:
dicts["fire1"]["timeLeft"] = dicts["fire1"]["fireHour"]
del dicts["fire1"]["fireAt"]
#del dicts["fire1"]["fireHour"]
if "fire2" in dicts:
if dicts["fire2"]["status"] == 2:
dicts["fire2"]["timeLeft"] = dicts["fire2"][
"fireAt"] + 3600 * dicts["fire2"]["fireHour"] + 1
if dicts["fire2"]["status"] == 1:
dicts["fire2"]["timeLeft"] = dicts["fire2"]["fireHour"]
del dicts["fire2"]["fireAt"]
#del dicts["fire2"]["fireHour"]
if "fire3" in dicts:
if dicts["fire3"]["status"] == 2:
dicts["fire3"]["timeLeft"] = dicts["fire3"][
"fireAt"] + 3600 * dicts["fire3"]["fireHour"] + 1
if dicts["fire3"]["status"] == 1:
dicts["fire3"]["timeLeft"] = dicts["fire3"]["fireHour"]
del dicts["fire3"]["fireAt"]
#del dicts["fire3"]["fireHour"]
dicts["siegeStatus"], dicts[
"siegeStatusChangeAt"] = self.getSiegeStatusInfo()
dicts["siegeGuildStatus"] = self.siegeGuildStatus
if len(dicts["mKeys"]) > 0:
dicts["mKeys"].append("siegeStatus")
dicts["mKeys"].append("siegeStatusChangeAt")
dicts["mKeys"].append("siegeGuildStatus")
return dicts
def _pvpBattleResult(request, response):
"""
竞技场
"""
player = request.player
target_player_id = getattr(request.logic_request, "oppId", 0)
playback = getattr(request.logic_request, "playback", [])
layout = getattr(request.logic_request, "layout", [])
isWin = getattr(request.logic_request, "isWin", 0)
summary = getattr(request.logic_request, "summary", 0) #死亡情况
powerrank = getattr(request.logic_request, "powerRank", 0) #战斗力
now = datetime.datetime.now()
hour = now.hour
# 未达到竞技场等级。
if not player.isOpenArena:
AlertHandler(
player, response, AlertID.ALERT_LEVEL_SHORTAGE,
u"_pvpBattleResult:playerLevel(%s) startLevel(%s)" %
(player.level, Static.PVP_LEVEL))
# 未到竞技场开启时间
week = now.isoweekday()
if week == Static.PVP_STOP_WEEK and hour < Static.PVP_STOP_HOUR:
response.logic_response.set("openState", 2)
return response
player.update_hero_layout(layout)
target_player = get_player(target_player_id, False)
# 验证是否有对面的玩家。
if not target_player:
raise ErrorException(
player,
u"_pvpBattleResult:pvp target player is None:target player id(%s) is not existed"
% target_player_id)
rewards = pvp_fight(player, target_player, isWin)
if isWin:
player.task_going(Static.TASK_CATEGORY_ARENA_PK_SUCCESS, is_incr=True)
score = 0
for reward in rewards:
if reward["type"] == Static.SCORE_ID:
score = reward["count"]
# pvp 的分支,pvp已经没有邮件的功能了。改成战斗记录的操作了。
# send_battle_record(player=player, isWin=isWin, playerScore=player.PVP.score, playerRank=player.PVP.rank, targetPlayerScore=target_player.PVP.score, targetPlayerRank=target_player.PVP.rank, addScore=score,playerPowerRank = player.powerRank, targetPlayerId=target_player.pk,targetPlayerPowerRank=target_player.powerRank, playerVip=int(player.vip_level), playerIcon=player.iconId, targetPlayerVip=int(target_player.vip_level), targetPlayerIcon=target_player.iconId)
send_battle_record(player=player,
targetPlayer=target_player,
isWin=isWin,
category=1,
addScore=score,
playerHeroes=player.layoutHeroSimple_dict(),
targetHeroes=target_player.layoutHeroSimple_dict())
# 竞技场排名七天乐奖励
rank = 1000 - player.PVP.rank
rank = rank if rank > 0 else 0
player.seven_days_task_going(category=Static.SEVEN_TASK_CATEGORY_PVP_RANK,
number=rank,
is_incr=False,
with_top=True,
is_series=True)
player.PVP.update_oppIds()
## 这里至少是5个人.
opp_ids = player.PVP.get_oppIds()
sumOpps = []
new_oppids = random.sample(opp_ids, 5)
opps = get_pvp_players(new_oppids)
for opp in opps:
sumOpps.append(opp.pvp_view_data(True))
response.common_response.player.set("opps", sumOpps)
#战斗失败添加冷却时间
if not isWin:
player.PVP.updateCdTime()
player.PVP.update()
target_player.PVP.update()
response.common_response.player.set("arena", player.PVP.to_dict())
response.logic_response.set("heroLevelUp", [])
response.logic_response.set("oppName", target_player.name)
response.logic_response.set("rewards", rewards)
response.logic_response.set("openState", 1)
return response
def pvpSetUp(request, response):
'''
PVP阵容
'''
player = request.player
# 这个是选中敌人的id
target_player_id = getattr(request.logic_request, "oppId", 0)
category = getattr(request.logic_request, "category", 0) # 1竞技场 2掠夺 3攻城战
target_player = get_player(target_player_id, False)
#竞技场
if category == 1:
#竞技场未开放
if not player.isOpenArena:
AlertHandler(player, response, AlertID.ALERT_LEVEL_SHORTAGE,
u"pvpSetUp:PVP playerLevel(%s)" % (player.level))
return response
#耐力不足
if player.stamina < Static.PVP_SUB_STAMINA:
AlertHandler(player, response, AlertID.ALERT_STAMINA_NOT_ENOUGH,
u"pvpSetUp:stamina not enougth")
return response
now = datetime.datetime.now()
week = now.isoweekday()
hour = now.hour
if week == Static.PVP_STOP_WEEK and hour < Static.PVP_STOP_HOUR:
response.logic_response.set("openState", 2)
return
# 是否达到冷却时间。
# 从django里面取出来的时间类型是带有时区的复杂类型。所以需要将时区的信息去除掉。这样才能和正常的日期类型去做比较
player.PVP.cd_time = player.PVP.cd_time.replace(tzinfo=None)
if player.PVP.cd_time > datetime.datetime.now():
return response
# 每日战斗五次
if player.PVP.freeBattleCount <= 0:
return response
player.sub_stamina(Static.PVP_SUB_STAMINA)
# 扣除耐力
# 之所以放在请求战斗里面去做，主要是因为怕玩家中途杀掉进程，可以逃避扣除耐力的做法
player.PVP.subBattleCount()
player.PVP.update()
#PVP 战斗一次
player.dailytask_going(Static.DAILYTASK_CATEGORY_PK,
number=1,
is_incr=True,
is_series=True)
playback_data = {}
#竞技场
playback_data = {"leftArmyData": target_player.army_data}
response.logic_response.set("playback", playback_data)
response.logic_response.set("category", category)
response.logic_response.set("openState", 1)
# 场景目前是表里面配置了三十二个。如果以后表里面有修改，
response.logic_response.set("pvpSceneId", random.randint(1, 7) * 10)
elif category == 3:
#耐力不足
if target_player_id != -10001:
#攻城战未开放
if not player.isOpenSiege:
AlertHandler(
player, response, AlertID.ALERT_LEVEL_SHORTAGE,
u"pvpSetUp:siege playerLevel(%s)" % (player.level))
return response
if player.siege_be_challenging:
# 正在被攻击 不能进行匹配
AlertHandler(player, response,
AlertID.ALERT_SIEGE_BATTLE_BE_CHALLENGING,
u"siegeBattlePlayer:be challenging")
return response
if target_player_id != player.SiegeBattle.oppId:
# 匹配的对手和挑战的对手不统一
AlertHandler(
player, response, AlertID.ALERT_SIEGE_BATTLE_MATCH_AGAIN,
u"pvpSetUp:siege fight player(%s) is not match player(%s)"
% (target_player_id, player.SiegeBattle.oppId))
return response
# 移动堡垒检查
if not player.SiegeBattle.has_fort:
AlertHandler(player, response,
AlertID.ALERT_SIEGE_BATTLE_NO_FORT,
u"siegeBattlePlayer:fort is not enougth")
return response
if target_player_id > 0:
target_player.siege_be_challenged() # 设置被挑战的时间
player.siege_be_safedTime(240) # 攻击者被保护4分钟
# 消耗一个移动堡垒
player.SiegeBattle.use_fort()
response.common_response.player.set("siegeBattle",
player.SiegeBattle.to_dict())
playback_data = {"leftArmyData": target_player.building_army_data}
response.logic_response.set("playback", playback_data)
response.logic_response.set("category", category)
response.logic_response.set("openState", 1)
response.logic_response.set("pvpSceneId", random.randint(1, 7) * 10)
return response
def player(self):
from module.player.api import get_player
player = get_player(self.player_id, False)
return player
def allowedMemberJoinGuild(request, response):
"""
加入或者拒绝社团
"""
player = request.player
category = getattr(request.logic_request, "category", 0) # 1允许 ２ 拒绝
targetPlayerId = getattr(request.logic_request, "targetPlayerId", 0)
if player.guild.position not in [
Static.GUILD_CHAIRMAN_POSITION, Static.GUILD_VI_CHAIRMAN_POSITION
]:
# 不是会长不可以审核
return response
guildInfo = player.guild.guildInfo
if targetPlayerId and targetPlayerId not in guildInfo.requestMemberIds: #检查是否在请求列表中
guildInfo.self_release_lock()
return response
# 如果是拒绝的话，分为单个拒绝和拒绝所有
if category == 2:
if targetPlayerId:
targetPlayer = get_player(targetPlayerId, False)
# 从列表里面删除
player.guild.disallow_join_guild(targetPlayerId)
contents = []
contents.append({
"content": "fytext_300760",
"paramList": [guildInfo.name],
})
# 发送邮件通知对方，没有加入成功
send_system_mail(targetPlayer,
None,
"fytext_300762",
contents=contents)
else:
# 所有
for targetPlayerId in guildInfo.requestMemberIds:
targetPlayer = get_player(targetPlayerId, False)
# 再进行一次验证
if not targetPlayer.guildId:
contents = []
contents.append({
"content": "fytext_300760",
"paramList": [guildInfo.name],
})
send_system_mail(targetPlayer,
None,
"fytext_300762",
contents=contents)
player.guild.disallow_join_guild(targetPlayerId)
# 如果同意操作基本类似
elif category == 1:
targetPlayers = []
if targetPlayerId:
targetPlayer = get_player(targetPlayerId)
targetPlayers.append(targetPlayer)
else:
for id in guildInfo.requestMemberIds:
targetPlayer = get_player(id)
targetPlayers.append(targetPlayer)
for targetPlayer in targetPlayers:
contents = []
contents.append({
"content": "fytext_300759",
"paramList": [guildInfo.name],
})
send_system_mail(targetPlayer,
None,
"fytext_300761",
contents=contents)
player.guild.allow_join_guild(targetPlayer)
guildInfo.save()
response.common_response.player.set("guild", player.guild.to_dict())
return response
def purchase_callback(request):
"""
支付回调
"""
AppID = request.POST.get("AppID", "")
OrderSerial = request.POST.get("OrderSerial", "")
CooperatorOrderSerial = request.POST.get("CooperatorOrderSerial", "")
Sign = request.POST.get("Sign", "")
Content = request.POST.get("Content", "")
secret_key = settings.CHANNELS["baidu"]["secret_key"]
sign = hashlib.md5("%s%s%s%s%s" %
(AppID, OrderSerial, CooperatorOrderSerial, Content,
secret_key)).hexdigest()
result = {
"AppID": AppID,
"ResultCode": 0,
"resultMsg": "",
"Sign": "",
"Content": ""
}
if sign != Sign:
result["resultMsg"] = u"Sign Error"
else:
contentStr = base64.b64decode(Content)
#json解析
content = simplejson.loads(contentStr)
order = get_order(CooperatorOrderSerial)
if not order:
result["ResultMsg"] = "No order"
else:
if not order.is_success:
order.notify_data = simplejson.dumps(content)
order.plat_order_id = OrderSerial
yuanbo = get_yuanbo(order.yuanbo_id)
#if yuanbo.price <= content["OrderMoney"] and content["OrderStatus"] == 1:
if content["OrderStatus"] == 1:
player = get_player(order.player_id)
add_yuanbo, is_first = recharge_yuanbo(
player, yuanbo, info="baidu recharge")
order.yuanbo = add_yuanbo
order.is_first = is_first
order.success()
player.update()
else:
order.failure()
order.save()
result["ResultCode"] = 1
result["Sign"] = hashlib.md5(
"%s%s%s" %
(result["AppID"], result["ResultCode"], secret_key)).hexdigest()
return HttpResponseJson(result)
