def instanceBoxOpen(request, response):
'''
打开章节宝箱
'''
rewards = []
player = request.player
instance_id = getattr(request.logic_request, "instanceId", 0)
chestLevel = getattr(request.logic_request, "level", 0)
category = getattr(request.logic_request, "category", 0)
if category == 2:
isElite = True
star_data = Static.ELITE_STAR_CHEST_OPEN_COUNTS
else:
isElite = False
star_data = Static.STAR_CHEST_OPEN_COUNTS
playerinstance_star = get_all_player_star_by_instance_id(player, instance_id, isElite)
if playerinstance_star < star_data[chestLevel]:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_CHEST_CAN_NOT_OPEN, u"instanceBoxOpen:instatnce(%s) playerinstance_star(%s) chestlevel(%s)" % (instance_id, playerinstance_star, star_data[chestLevel]))
return response
if not player.chestWithDrawn(instance_id, chestLevel, isElite):
AlertHandler(player, response, AlertID.ALERT_INSTANCE_CHEST_ALREADY_OPEN, u"instanceBoxOpen:instatnce(%s) chest is opened" % (instance_id))
return response
rewards = get_chest_rewards(player, instance_id, chestLevel, isElite)
for reward in rewards:
rewardTemp = CommonReward(reward["type"], reward["count"], 0)
reward_send(player, rewardTemp, info=u"打开章节宝箱:%s" % instance_id)
response.common_response.player.set("starBox", {"history" : player.starChest})
response.common_response.player.set("eliteStarBox", {"history" : player.eliteStarChest})
response.logic_response.set("rewards", rewards)
return response
def vipRewardsGet(request, response):
player = request.player
vip_level = getattr(request.logic_request, "vipLevel", 0)
vip_level = int(vip_level)
if not player.can_buy_vip_bag(vip_level) and vip_level > 0:
AlertHandler(
player, response, AlertID.ALERT_VIP_CAN_NOT_BUY,
u"vipRewardsGet:vipLevel(%s) playerVipLevel(%s) can_buy_vip_bag" %
(vip_level, player.vip_level))
return response
vip = get_vip(vip_level)
if player.yuanbo < vip.giftBagDiamond:
AlertHandler(
player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
u"vipRewardsGet:vipLevel(%s) playerVipLevel(%s) price(%s) playerYuanbo(%s)"
% (vip_level, player.vip_level, vip.giftBagDiamond, player.yuanbo))
return response
player.buy_vip_bag(vip_level)
rewards = vip.giftRewards
info = u"VIP礼包:%s" % vip_level
for reward in rewards:
reward_send(player, reward, info)
player.sub_yuanbo(vip.giftBagDiamond, info)
response.common_response.player.set("vip", player.vip)
return response
def smallGameFinish(request, response):
'''
小游戏
'''
player = request.player
score = getattr(request.logic_request, "score", 0) #得分
#次数不足
if player.smallGameLeftTimes <= 0:
return response
rewards = []
# 获取小游戏的奖励
gameRules = get_smallGames()
# 按照积分顺序从大到小排
gameRules = sorted(gameRules,key=lambda x: x.score)
info = u'小游戏奖励'
for gameRule in gameRules:
if score < gameRule.score:
rewards = gameRule.rewards
break
# 奖励分为三个类别，金币，钻石，和物品
for reward in rewards:
reward_send(player, reward, info)
player.smallGameBattle()
player.dailytask_going(Static.DAILYTASK_CATEGORY_SMALLGAME, number=1, is_incr=True, is_series=True)
response.logic_response.set("rewards", [reward.to_dict() for reward in rewards])
response.common_response.player.set("smallGameLeftTimes", player.smallGameLeftTimes)
return response
def elementTowerInstanceStart(request, response):
"""
活动副本结算
"""
player = request.player
isWin = getattr(request.logic_request, "isWin", False)
star = getattr(request.logic_request, "star", 0)
levelId = getattr(request.logic_request, "levelId", 0)
towerId = getattr(request.logic_request, "towerId", 0)
if player.elementTower.towerId != towerId:
raise ErrorException(player, u"elementTowerInstanceStart towerId(%s) is error" % towerId)
if player.elementTower.levelId != levelId:
raise ErrorException(player, u"elementTowerInstanceStart levelId(%s) is error" % levelId)
if not player.elementTower.levelIsOpen:
raise ErrorException(player, u"elementTowerInstanceStart levelStatus(%s) is error" % player.elementTower.levelStatus)
data = player.elementTower.fight(isWin, star)
#七日任务 日常任务
if isWin:
player.seven_days_task_going(Static.SEVEN_TASK_CATEGORY_ELEMENTTOWER_SUCCESS, number=levelId/3, is_incr=False, with_top=True, is_series=True)
player.dailytask_going(Static.DAILYTASK_CATEGORY_ELEMENTTOWER_FIGHT, number=1, is_incr=True, is_series=True)
rewards = data["rewards"]
for reward in rewards:
reward_send(player, reward, info=u"爬塔结算:%s:%s" % (towerId,levelId))
response.logic_response.set("rewards", [reward.to_dict() for reward in rewards])
response.common_response.player.set("elementTower", player.elementTower.to_dict())
return response
def dailyTaskActivityReward(request, response):
"""
领取活跃度奖励
"""
player = request.player
activityId = getattr(request.logic_request, "activityId", 0)
activity = get_dailytask_activity(activityId)
if activityId in player.activityBoxIds:
AlertHandler(
player, response, AlertID.ALERT_DAILYTASK_REWARD_RECEIVED,
u"dailyTaskActivityReward:activityId(%s) had received" %
(activityId))
return response
if player.dailyTaskActivity < activity.activityValue:
AlertHandler(
player, response, AlertID.ALERT_DAILYTASK_ACTIVITY_NOT_ENOUGH,
u"dailyTaskActivityReward:activity(%s) need (%s) player have (%s)"
% (activityId, activity.activityValue, player.dailyTaskActivity))
return response
# 完成日常任务会获取活跃度
player.activityBoxIds.append(activityId)
player.set_update("activityBoxIds")
for reward in activity.rewards:
reward_send(player, reward, info=u"活跃度奖励")
return response
def buildingDismantle(request, response):
"""
建筑拆除
"""
player = request.player
playerbuilding_id = getattr(request.logic_request, "playerBuildingId", 0)
rewards = []
playerbuilding = player.buildings.get(playerbuilding_id)
if not playerbuilding:
raise ErrorException(
player,
u"buildingDismantle:no playerbuilding(%s)" % (playerbuilding_id))
if not playerbuilding.building.canRemove:
raise ErrorException(
player,
u"buildingDismantle:can not dismantle(%s)" % (playerbuilding_id))
info = u"建筑拆除"
rewards = playerbuilding.building.removeRewardIds
for reward in rewards:
reward_send(player, reward, info=info)
player.delete_building(playerbuilding_id, True)
ActionLogWriter.building_delete(player, playerbuilding_id,
playerbuilding.building_id, info)
response.logic_response.set("rewards",
[reward.to_dict() for reward in rewards])
return response
def taskDailyReward(request, response):
"""
日常任务领取
"""
player = request.player
task_id = getattr(request.logic_request, "taskId", 0)
task_id = int(task_id)
task = get_dailytask(task_id)
if player.dailytask_is_done(task.category):
player.dailytask_done(task.category)
#扫荡券
if task.is_vip_sweep:
vip = get_vip(player.vip_level)
acquire_item(player,
Static.ITEM_SWEEP_ID,
number=vip.sweepCount,
info=u"VIP领取")
else:
for reward in task.rewards:
reward_send(player, reward, info=u"日常任务领取")
else:
player.update_dailytask(task.category)
AlertHandler(player, response, AlertID.ALERT_DAILYTASK_UNDONE,
u"taskDailyReward:taskGid(%s) is not done" % (task_id))
return response
def loginBoxReward(request, response):
"""
领取登陆宝箱奖励
"""
activityId = getattr(request.logic_request, "activityId", 0)
param = getattr(request.logic_request, "param", 0)
player = request.player
_, playeractivity = player.activities.get_or_create(activityId)
if not playeractivity.activity.isCountinueLogin or not playeractivity.activity.isOpen(
player.userid):
raise ErrorException(player,
u"loginBoxReward:activityId:%s" % activityId)
rewards = playeractivity.get_login_boxrewards(param)
view_rewards = []
info = u"领取连续登陆(%s:%s)宝箱奖励" % (activityId, param)
for reward in rewards:
reward_send(player, reward, info=info)
# 为了使前端的奖励数据看起来正常
reward.count = reward.count
view_rewards.append(reward.to_dict())
response.logic_response.set("rewards", view_rewards)
return response
def elementTowerInstanceSweep(request, response):
"""
扫荡
"""
player = request.player
if player.elementTower.isSweep:
return response
data = player.elementTower.sweep()
_t1Rewards = []
for rewards in data["rewards"]:
_t2Rewards = []
for reward in rewards:
reward_send(player, reward, info=u"元素之塔扫荡结算")
_t2Rewards.append(reward.to_dict())
_t1Rewards.append(_t2Rewards)
_t3Rewards = []
for rewards in data["freeBoxRewards"]:
reward_send(player, rewards, info=u"元素之塔扫荡开启免费宝箱")
_t3Rewards.append(rewards.to_dict())
player.dailytask_going(Static.DAILYTASK_CATEGORY_ELEMENTTOWER_FIGHT, number=1, is_incr=True, is_series=True)
response.common_response.player.set("elementTower", player.elementTower.to_dict())
response.logic_response.set("rewards", _t1Rewards)
response.logic_response.set("freeBoxRewards", _t3Rewards)
return response
def activityReward(request, response):
"""
领取活动奖励
"""
activityId = getattr(request.logic_request, "activityId", 0)
param = getattr(request.logic_request, "param", 0)
player = request.player
_, playeractivity = player.activities.get_or_create(activityId)
if playeractivity.activity.isCountinueLogin and not playeractivity.activity.isOpen(
player.userid):
raise ErrorException(
player, u"activityReward:activityId:%s is ERROR" % activityId)
data = playeractivity.get_rewards(param)
rewards = data["rewards"]
number = data["number"]
view_rewards = []
info = u"领取活动(%s:%s)奖励" % (activityId, param)
for reward in rewards:
reward_send(player, reward, info=info, number=number)
rewardDict = reward.to_dict()
rewardDict["count"] = reward.count * number
view_rewards.append(rewardDict)
response.logic_response.set("rewards", view_rewards)
return response
def elementTowerBoxOpen(request, response):
"""
元素之塔宝箱开启状态
"""
player = request.player
status = getattr(request.logic_request, "status", 0) #0 放弃 1 开启
category = getattr(request.logic_request, "category", 0)
levelId = getattr(request.logic_request, "levelId", 0)
#正常逻辑开箱子
if not player.elementTower.isInSweep:
if not player.elementTower.boxCanOpen:
raise ErrorException(player, u"elementTowerBoxOpen levelStatus(%s) is error" % player.elementTower.levelStatus)
cost = player.elementTower.tower.levels[player.elementTower.levelId - 1].diamondCosts[player.elementTower.diamondBoxIndex]
if status and player.yuanbo < cost:
AlertHandler(player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH, u"elementTowerBoxOpen:playerDiamond(%s) costDiamond(%s)" % (player.yuanbo, cost))
return response
if status and cost:
player.sub_yuanbo(cost, info=u"元素之塔%s, level(%s)开启宝箱, %s" % (player.elementTower.towerId, player.elementTower.levelId, player.elementTower.diamondBoxIndex))
rewards = player.elementTower.openDiamondBox(status)
#扫荡开箱子
else:
if "boxLevelIds" not in player.elementTower.sweepInfo or len(player.elementTower.sweepInfo["boxLevelIds"]) == 0:
raise ErrorException(player, u"elementTowerBoxOpen sweep not box can open")
# levelId = player.elementTower.sweepInfo["boxLevelIds"][0][0]
# boxIndex = player.elementTower.sweepInfo["boxLevelIds"][0][1]
cost = 0
if status:
cost = player.elementTower.openSweepDiamondBoxCost(category, levelId)
if status and player.yuanbo < cost:
AlertHandler(player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH, u"elementTowerBoxOpen:sweep:playerDiamond(%s) costDiamond(%s)" % (player.yuanbo, cost))
return response
if status and cost:
player.sub_yuanbo(cost, info=u"元素之塔%s, sweep level(%s)开启宝箱, %s" % (player.elementTower.towerId, levelId, status))
rewards = player.elementTower.openSweepDiamondBox(status, category, levelId)
for reward in rewards:
reward_send(player, reward, info=u"开宝箱奖励:%s:%s" % (player.elementTower.towerId,player.elementTower.levelId))
response.logic_response.set("rewards", [reward.to_dict() for reward in rewards])
response.logic_response.set("category", category)
response.common_response.player.set("elementTower", player.elementTower.to_dict())
return response
def fight(self, star, isWin):
"""
战斗结算
"""
# 普通副本
data = {"star": 0}
rewards = []
hero_levelup_ids = []
if isWin:
data["star"] = star
# 这都是继承自父类的方法
golds = int(self.instancelevel.golds[0])
woods = int(self.instancelevel.woods[0])
hero_exp = int(self.instancelevel.heroExp[0])
exp = self.instancelevel.playerExp
# 随机的奖励在这里操作
# 这个rewards 是具体要发到玩家身上的奖励
rewards = self.make_rewards()
if golds:
rewards.append({"type": Static.GOLD_ID, "count": golds})
if exp:
rewards.append({"type": Static.XP_ID, "count": exp})
if woods:
rewards.append({"type": Static.WOOD_ID, "count": woods})
# 根据上面的数据直接拿到奖励,然后发放
for rewardDict in rewards:
rewardTemp = CommonReward(rewardDict["type"],
rewardDict["count"], 0)
reward_send(self.player,
rewardTemp,
info=u"副本结算:%s" % self.level_id)
for i in range(0, len(self.player.heroLayout)):
playerhero = self.player.heroes.get(self.player.heroLayout[i])
if playerhero.add_xp(hero_exp, self.player):
hero_levelup_ids.append(playerhero.id)
self.player.update_hero(playerhero, True)
self.add_count()
self.success(star)
data["rewards"] = rewards
data["heroLevelUp"] = hero_levelup_ids
return data
def mysteryShopBuy(request, response):
"""
神秘商店兑换
"""
player = request.player
info = u"神秘商店兑换"
shop_id = getattr(request.logic_request, "mysteryShopId", 0)
#shop_id = int(shop_id)
shop_item = get_mysteryshop(shop_id)
if not shop_item:
raise ErrorException(
player, u"mysteryShopBuy:shopitem(%s) no existed" % shop_id)
if not player.mysteryshop.can_exchange(shop_id):
response.common_response.player.set("mysteryShop",
player.mysteryshop.to_dict())
AlertHandler(
player, response, AlertID.ALERT_MYSTERYSHOP_CAN_NOT_EXCHANGE,
u"mysteryShopBuy:shopitem(%s) can not buyed buyItem(%s) shopItem(%s)"
% (shop_id, str(
player.mysteryshop.buyItem), str(player.mysteryshop.shopItem)))
return response
if shop_item.diamond > 0:
if player.yuanbo < shop_item.diamond:
AlertHandler(
player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
u"mysteryShopBuy:shopitem(%s) can not buyed diamond(%s) playerYuanbo(%s)"
% (shop_id, shop_item.diamond, player.yuanbo))
return response
else:
if player.gold < shop_item.gold:
AlertHandler(
player, response, AlertID.ALERT_GOLD_NOT_ENOUGH,
u"mysteryShopBuy:shopitem(%s) can not buyed gold(%s) playerCouragePoint(%s)"
% (shop_id, shop_item.gold, player.couragepoint))
return response
if shop_item.diamond > 0:
player.sub_yuanbo(shop_item.diamond, info=info)
else:
player.sub_gold(shop_item.gold, info=info)
player.mysteryshop.exchange(shop_item.pk)
reward_send(player, shop_item.reward, info=u"神秘商店购买")
response.common_response.player.set("mysteryShop",
player.mysteryshop.to_dict())
return response
def fight(self, star, isWin):
"""
战斗结算
"""
# 精英副本
data = {}
rewards = []
hero_levelup_ids = []
data["star"] = 0
if isWin:
self.add_count()
self.success(star)
golds = self.eliteInstancelevel.eliteGold
woods = self.eliteInstancelevel.elitewoods[0]
hero_exp = self.eliteInstancelevel.eliteHeroExp
exp = self.eliteInstancelevel.elitePlayerExp
rewards = self.make_rewards()
if golds:
rewards.append({"type": Static.GOLD_ID, "count": golds})
if woods:
rewards.append({"type": Static.WOOD_ID, "count": woods})
if exp:
rewards.append({"type": Static.XP_ID, "count": exp})
for rewardDict in rewards:
rewardTemp = CommonReward(rewardDict["type"],
rewardDict["count"], 0)
reward_send(self.player,
rewardTemp,
info=u"精英副本结算:%s" % self.level_id)
for i in range(0, len(self.player.heroLayout)):
playerhero = self.player.heroes.get(self.player.heroLayout[i])
if playerhero.add_xp(hero_exp, self.player):
hero_levelup_ids.append(playerhero.id)
self.player.update_hero(playerhero, True)
data["rewards"] = rewards
data["heroLevelUp"] = hero_levelup_ids
return data
def offlineRewardGet(request, response):
player = request.player
if not player.offlinebonus:
return response
rewards = player.offlinebonus
view_rewards = []
info = u"离线奖励"
for reward in rewards:
tmp_reward = CommonReward(reward["type"], reward["count"], 0)
reward_send(player, tmp_reward, info=info)
view_rewards.append(tmp_reward.to_dict())
player.offlinebonus = []
player.set_update("offlinebonus")
response.logic_response.set("rewards", view_rewards)
response.common_response.player.set("offlinebonus", player.offlinebonus)
return response
def sevenDaysTaskReward(request, response):
"""
七天任务奖励领取
"""
player = request.player
task_id = getattr(request.logic_request, "taskId", 0)
task_id = int(task_id)
task = get_seven_days_task(task_id)
# 先来判断任务是否完成
if str(task_id) in player.completeSevenTasks and player.completeSevenTasks[
str(task_id)] == 0:
player.completeSevenTasks[str(task_id)] = 1
for reward in task.rewards:
reward_send(player, reward, info=u"七天乐任务领取")
player.set_update("completeSevenTasks")
return response
def sevenDaysHalfBuy(request, response):
"""
七天乐半价购买
"""
player = request.player
sevenId = getattr(request.logic_request, "sevenId", 0)
sevenPrice = get_sevenDaysHalfPrice(sevenId)
if player.daysFromcreated > 9 or player.daysFromcreated < sevenId:
AlertHandler(
player, response, AlertID.ALERT_SEVENDAYS_IS_NOT_ALLOWED,
u"sevenDaysHalfBuy:playerdays not between 1 and 9 had received" %
(player.daysFromcreated))
return response
if sevenPrice.id in player.halfBuyIds:
AlertHandler(
player, response, AlertID.ALERT_SEVENDAYS_ONLY_ONCE,
u"sevenDaysHalfBuy:this is item(%s) had buyed" % (sevenPrice.id))
return response
if player.yuanbo < sevenPrice.itemCost:
AlertHandler(
player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
u"sevenDaysHalfBuy: sevenPrice cost (%s) and player has (%s)" %
(sevenPrice.itemCost, player.yuanbo))
return response
reward_send(player, sevenPrice.reward, info=u"七天半价购买%s" % sevenPrice.id)
player.halfBuyIds.append(sevenPrice.pk)
player.set_update("halfBuyIds")
player.sub_yuanbo(sevenPrice.itemCost, info=u"七天半价购买%s" % sevenPrice.id)
response.common_response.player.set("halfBuyIds", player.halfBuyIds)
if player.isOpenArena:
response.common_response.player.set("arena", player.PVP.to_dict())
return response
def taskReward(request, response):
"""
任务领取
"""
player = request.player
task_id = getattr(request.logic_request, "taskId", 0)
task_id = int(task_id)
task = get_task(task_id)
# 先来判断任务是否完成
if player.task_is_done(task.category):
player.task_done(task.category)
for reward in task.rewards:
reward_send(player, reward, info=u"任务领取")
else:
player.update_task(task.category)
AlertHandler(player, response, AlertID.ALERT_TASK_UNDONE,
u"taskReward:taskGid(%s) is not done" % (task_id))
return response
def buildingPlantHarvest(request, response):
'''
植物采摘
'''
player = request.player
playerplant_id = getattr(request.logic_request, "playerPlantId", 0)
playerbuildingplant = player.buildingplants.get(playerplant_id)
if playerbuildingplant.harvestLeftTimes <= 0:
AlertHandler(player, response, AlertID.ALERT_PLANT_HARVEST_OVER_MAX_NUMBER, u"buildingPlantHarvest:plant(%s) is not mature" % playerbuildingplant.plantId)
return response
if not playerbuildingplant.is_maturation:
AlertHandler(player, response, AlertID.ALERT_PLANT_HARVEST_NOT_MATURATION, u"buildingPlantHarvest:plant(%s) is not mature" % playerbuildingplant.plantId)
return response
info = u"植物采摘奖励"
rewards = []
rewards = playerbuildingplant.harvest()
for reward in rewards:
reward_send(player, reward, info=info)
player.update_buildingplant(playerbuildingplant, True)
response.logic_response.set("rewards", [reward.to_dict() for reward in rewards])
return response
def mailRewardsGet(request, response):
"""
邮件领取奖励
"""
player = request.player
mail_id = getattr(request.logic_request, "mailId", 0)
status = 2 #0领取成功 1已经领取过，不能重复领取 2无法领取
mail = get_mail(mail_id)
if mail and mail.is_system:
if not mail.is_accept:
# status = 1
#else:
for reward in mail.attachments:
tmp_reward = CommonReward(reward["type"], reward["count"], 0)
reward_send(player, tmp_reward, info=mail.title)
status = 0
player.delete_mail(mail.pk)
mail.delete()
response.logic_response.set("status", status)
return response
def heroGacha(request, response):
player = request.player
is_ten = getattr(request.logic_request, "isTen", False)
tavernId = getattr(request.logic_request, "tavernId", 0)
rewards = []
# 这个是先判断是什么抽奖，是金币还是钻石类型。
tavern = get_tavern(tavernId)
if not tavern:
raise ErrorException(player, u"heroGacha:no tavern(%s)" % tavernId)
else:
#第一次十连抽使用ID = 3的抽奖配置
if tavern.is_diamond and player.isFirstTenGacha and is_ten:
gashapon_id = 3
else:
gashapon_id = tavern.gashapon_id
gashapon = get_gashapon(gashapon_id)
is_new, playergashapon = player.gashapons.get_or_create(gashapon.pk)
playerGashaponItem = None
# 如果是金币
if tavern.is_gold:
# 不是十连抽
if not is_ten:
#
if not player.gashapon_is_gold_free and not reward_cost_check(
player, tavern.tavern_cost):
AlertHandler(
player, response, AlertID.ALERT_GOLD_NOT_ENOUGH,
u"heroGacha:tavern(%s) needGold(%s) playerGold(%s)" %
(tavern.pk, tavern.tavern_cost.count, player.gold))
return response
else:
if not reward_cost_check(player, tavern.tavern_tencost):
AlertHandler(
player, response, AlertID.ALERT_GOLD_NOT_ENOUGH,
u"heroGacha:tavern(%s) needGold(%s) playerGold(%s)" %
(tavern.pk, tavern.tavern_tencost.count, player.gold))
return response
else:
if not is_ten:
playerGashaponItem = player.items.get(
Static.ITEM_DIAMOND_GASHAPON_ID)
if not playerGashaponItem or not playerGashaponItem.can_sub(1):
if not player.gashapon_is_yuanbo_free and not reward_cost_check(
player, tavern.tavern_cost):
AlertHandler(
player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
u"heroGacha:tavern(%s) needYuanbo(%s) playerYuanbo(%s)"
% (tavern.pk, tavern.tavern_cost.count,
player.yuanbo))
return response
else:
if not reward_cost_check(player, tavern.tavern_tencost):
AlertHandler(
player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
u"heroGacha:tavern(%s) needYuanbo(%s) playerYuanbo(%s)"
% (tavern.pk, tavern.tavern_tencost.count,
player.yuanbo))
return response
if tavern.is_gold:
if not is_ten and player.gashapon_is_gold_free:
player.use_gashapon_gold_free()
else:
if is_ten:
reward_cost(player,
tavern.tavern_tencost,
info=u"抽奖:%s:%s" % (gashapon.name, is_ten))
else:
reward_cost(player,
tavern.tavern_cost,
info=u"抽奖:%s:%s" % (gashapon.name, is_ten))
else:
if not is_ten and player.gashapon_is_yuanbo_free:
player.use_gashapon_yuanbo_free()
else:
if is_ten:
reward_cost(player,
tavern.tavern_tencost,
info=u"抽奖:%s:%s" % (gashapon.name, is_ten))
else:
if not playerGashaponItem or not playerGashaponItem.can_sub(
1):
reward_cost(player,
tavern.tavern_cost,
info=u"抽奖:%s:%s" % (gashapon.name, is_ten))
else:
playerGashaponItem.sub(1, info=u"英雄单抽卡")
# 新手引导的话就只有新手引导，否则就走其他的抽奖
if player.tutorial_id == Static.TUTORIAL_ID_GASHAPON_2 and player.tutorial[
'status'] != 2:
playerhero = acquire_hero(player, 112000400, u"新手引导", star=6)
playerhero.gashapon_number = 1
units = [playerhero]
player.tutorial_complete()
player.next_tutorial_open()
else:
if is_ten:
gashapon_count = 10
if not tavern.is_gold:
player.seven_days_task_going(
Static.SEVEN_TASK_CATEGORY_GASHAPON,
number=1,
is_incr=True,
with_top=False,
is_series=True)
player.tenDiamondCount += 1
player.set_update("tenDiamondCount")
else:
gashapon_count = 1
units = playergashapon.acquire(player,
gashapon,
count=gashapon_count)
#第一次十连抽使用ID = 3的抽奖配置
if tavern.is_diamond and player.isFirstTenGacha and is_ten:
player.useFirstTenGacha()
player.gashapons.update(playergashapon)
player.dailytask_going(Static.DAILYTASK_CATEGORY_GASHAPON,
number=len(units),
is_incr=True,
is_series=True) #召唤大师
if is_ten and tavern.tenReward:
reward_send(player, tavern.tenReward, info=u"%s:10连抽" % tavern.pk)
elif not is_ten and tavern.reward:
reward_send(player, tavern.reward, info=u"%s:单抽" % tavern.pk)
for unit in units:
reward = {"count": unit.gashapon_number, "type": unit.obj_id}
if hasattr(unit, "from_hero"):
reward["fromHero"] = unit.from_hero
else:
reward["fromHero"] = False
rewards.append(reward)
response.common_response.player.set("tavern", player.tavern)
response.logic_response.set("rewards", rewards)
return response
def raceInstanceStart(request, response):
"""
活动副本结算
"""
player = request.player
raidinstance_id = getattr(request.logic_request, "raidId", 0)
level_id = getattr(request.logic_request, "instanceId", 0)
waveCount = getattr(request.logic_request, "waveCount", 0)
star = getattr(request.logic_request, "star", 0)
isWin = getattr(request.logic_request, "isWin", False)
heroLayoutData = getattr(request.logic_request, "heroLayoutData", [])
percentage = getattr(request.logic_request, "percentage", 0.0)
summary = getattr(request.logic_request, "summary", {})
if percentage > 1:
percentage = 0
# 活动副本章节
raidinstance = get_raidinstance(raidinstance_id)
if not raidinstance:
raise ErrorException(player, u"raceInstanceStart:raid instance id error (%s)" % raidinstance_id)
if level_id not in raidinstance.raidLevel_ids:
raise ErrorException(player, u"raceInstanceStart:raid instance level id error (%s)" % level_id)
raidlevel = get_raidlevel(level_id)
if raidlevel.minUserLevel > player.level:
AlertHandler(player, response, AlertID.ALERT_LEVEL_SHORTAGE, u"raceInstanceStart:instance(%s) openlevel(%s) playerlevel(%s)" % (level_id, raidlevel.minUserLevel, player.level))
return response
#次数check
_, playerraidinstance = player.raidinstances.get_or_create(raidinstance_id)
vip = get_vip(player.vip_level)
# 爬塔没有次数限制
if playerraidinstance.succeedCount >= vip.titanCount and not raidinstance.category == 6:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_FIGHT_COUNT_EXCEED_MAX, u"raceInstanceStart:instance(%s) level_id(%s) fight number(%s) exceed maxCount(%s)" % (raidinstance.id, level_id, playerraidinstance.succeedCount, vip.titanCount))
return response
player.update_hero_layout(heroLayoutData)
data = playerraidinstance.fight(raidlevel, isWin, percentage)
player.update_raidinstance(playerraidinstance, True)
if isWin:
# raidinstance.powerCost 消耗的体力 现改为消耗耐力
player.sub_stamina(raidinstance.powerCost)
#if raidinstance.category == 6:
# if level_id > player.lastRaidId:
# # 记录最新的塔id
# player.lastRaidId = level_id
# player.set_update("lastRaidId")
# # 记录当前的波数
# player.dailyWaveCount = waveCount
# player.set_update("dailyWaveCount")
# # 副本完成状态
# # 记录当前一共有的星星的数
# player.towerStar += star
# player.set_update("towerStar")
# # 顺序记录副本的通关星星状态
# # todo 这里没想好怎么做。暂时先屏蔽了
# # player.towerSweep.append(level_id)
# # player.towerSweep.append(star)
# player.set_update("towerSweep")
# # -1 继续进副本战斗 0去开箱领奖 1-5领了几层箱子
# if waveCount % 3 == 0:
# # 记录当前一层完成状态更改
# player.towerStatus = 0
# player.set_update("towerStatus")
# player.choiceBuffs()
# response.logic_response.set("buffs", player.buyBuffsList)
# player.seven_days_task_going(Static.SEVEN_TASK_CATEGORY_RACE_INSTANCE, number=player.dailyWaveCount, is_incr=False, with_top=True, is_series=True)
#else:
player.dailytask_going(Static.DAILYTASK_CATEGORY_RACE_INSTANCE, number=1, is_incr=True, is_series=True)
#if raidinstance.category == 6:
# player.dailytask_going(Static.DAILYTASK_CATEGORY_EXPEDITION_SUCCESS, number=1, is_incr=True, is_series=True)
rewards = data["rewards"]
heroLevelUp = []
heroLevelUp = data["heroLevelUp"]
number = data["number"]
for rewardDict in rewards:
rewardTemp = CommonReward(rewardDict["type"], rewardDict["count"], 0)
rewardDict["count"] *= number
reward_send(player, rewardTemp, info=u"活动副本结算:%s:%s" % (raidinstance_id,level_id), number=number)
response.logic_response.set("rewards", rewards)
response.logic_response.set("heroLeveleUp",heroLevelUp)
response.logic_response.set("summary",summary)
#response.common_response.player.set("towerStar", player.towerStar)
#response.common_response.player.set("towerStatus", player.towerStatus)
#response.common_response.player.set("buyBuffsList", player.buyBuffsList)
response.common_response.player.set("soldiers", player.armies.to_dict())
response.common_response.player.set("populationCost", player.populationCost)
response.common_response.player.set("raidInstance", {"instances":get_player_open_raidinstance(player)})
return response
def instanceSweep(request, response):
'''
扫荡
'''
level_id = getattr(request.logic_request, "instanceId", 0)
count = getattr(request.logic_request, "count", 0)
category = getattr(request.logic_request, "category", 0)
player = request.player
if category == 2:
isElite = True
instancelevel = get_eliteinstancelevel(level_id)
playerinstancelevel = player.eliteinstancelevels.get(level_id)
else:
isElite = False
instancelevel = get_instancelevel(level_id)
playerinstancelevel = player.instancelevels.get(level_id)
#副本没有开启
if not playerinstancelevel:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_NOT_OPEN, u"instanceSweep:instance(%s) is not open" % level_id)
return response
if not playerinstancelevel.can_sweep():
AlertHandler(player, response, AlertID.ALERT_INSTANCE_CAN_NOT_SWEEP, u"instanceSweep:instance(%s) can not sweep" % level_id)
return response
# todo １０级以前不可以扫荡
if player.level < Static.SWEEP_OPEN_LEVEL:
return response
#扫荡卷判断
#Static.ITEM_TYPE_SWEEP 扫荡卷id
item_sweep = player.items.get(Static.ITEM_SWEEP_ID)
if item_sweep and item_sweep.count > 0:
use_diamond = False
else:
use_diamond = True
if player.vip_level < Static.SWEEP_VIP_LEVEL and use_diamond:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_SWEEP_VIP_ERROR, u"instanceSweep:vip(%s) error" % player.vip_level)
return response
#次数判断
if isElite:
maxCount = instancelevel.eliteMaxPlayCount
powerCost = instancelevel.elitePowerCost
else:
maxCount = instancelevel.maxPlayCount
powerCost = instancelevel.powerCost
if count > maxCount - playerinstancelevel.succeedCount:
count = maxCount - playerinstancelevel.succeedCount
if count == 0:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_FIGHT_COUNT_EXCEED_MAX, u"instanceSweep:instance(%s) fight number(%s) exceed maxCount(%s)" % (level_id, count, maxCount))
return response
#体力判断
if count > player.power/powerCost:
count = player.power/powerCost
if count == 0:
AlertHandler(player, response, AlertID.ALERT_POWER_NOT_ENOUGH, u"instanceSweep:instance(%s) power is not enough" % level_id)
return response
if not use_diamond and not item_sweep.can_sub(count):
AlertHandler(player, response, AlertID.ALERT_INSTANCE_ITEM_SWEEP_NOT_ENOUGH, u"instanceSweep:item sweep number (%s) not enough" % (item_sweep.count))
return response
if use_diamond:
if player.yuanbo < Static.SWEEP_INSTANCE_COST*count:
AlertHandler(player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH, u"instanceSweep:playerDiamond(%s) costDiamond(%s)" % (player.yuanbo, Static.SWEEP_INSTANCE_COST*count))
return response
player.sub_yuanbo(Static.SWEEP_INSTANCE_COST*count, info=u"扫荡")
else:
item_sweep.sub(count , info=u"扫荡:%s:%s" % (level_id, isElite))
rewards_list = playerinstancelevel.sweep(count)
for rewards in rewards_list:
for rewardDict in rewards:
rewardTemp = CommonReward(rewardDict["type"], rewardDict["count"], 0)
reward_send(player, rewardTemp, info=u"副本扫荡结算:%s" % level_id)
if not isElite:
player.sub_power(instancelevel.powerCost * count)
player.task_going(Static.TASK_CATEGORY_INSTANCE, number=count, c1=instancelevel.id, is_incr=False, is_series=False)
else:
player.sub_power(instancelevel.elitePowerCost * count)
player.task_going(Static.TASK_CATEGORY_ELIT_INSTANCE, number=count, c1=instancelevel.pk, is_incr=False, is_series=False)
player.dailytask_going(Static.DAILYTASK_CATEGORY_ELIT_INSTANCE, number=count, is_incr=True, is_series=True)
player.dailytask_going(Static.DAILYTASK_CATEGORY_INSTANCE, number=count, is_incr=True, is_series=True)
if isElite:
player.update_eliteinstancelevel(playerinstancelevel, True)
else:
player.update_instancelevel(playerinstancelevel, True)
response.logic_response.set("rewards", rewards_list)
return response