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 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 buildingMove(request, response):
"""
建筑物移动
"""
playerbuilding_ids = getattr(request.logic_request, "buildings", 0)
player = request.player
for _pb in playerbuilding_ids:
if not _pb["category"]:
playerbuilding = player.buildings.get(_pb["key"])
if not playerbuilding:
raise ErrorException(
player,
u"buildingBuild:playerbuilding(%s) is not existed" %
_pb["key"])
playerbuilding.centerX = _pb["centerX"]
playerbuilding.centerY = _pb["centerY"]
player.update_building(playerbuilding, True)
else:
#植物
playerplant = player.buildingplants.get(_pb["key"])
if not playerplant:
raise ErrorException(
player, u"buildingBuild:playerplant(%s) is not existed" %
_pb["key"])
playerplant.centerX = _pb["centerX"]
playerplant.centerY = _pb["centerY"]
player.update_buildingplant(playerplant, True)
return response
def heroLevelUp(request, response):
"""
英雄升级
"""
playerhero_id = getattr(request.logic_request, "playerHeroId", 0)
item_ids = getattr(request.logic_request, "itemIds", 0)
player = request.player
info = u"英雄升级:%s" % playerhero_id
playerhero = player.heroes.get(playerhero_id)
if not playerhero:
raise ErrorException(
player,
u"heroLevelUp:playerhero(%s) is not existed" % (playerhero_id))
items = dict(zip(item_ids[0:len(item_ids):2], item_ids[1:len(item_ids):2]))
total_xp = 0
for item_id, count in items.items():
playeritem = player.items.get(item_id)
if not playeritem:
raise ErrorException(
player, u"heroLevelUp:playeritem(%s) no existed" % (item_id))
if not playeritem.can_sub(count):
#更新数据
player.update_item(playeritem)
AlertHandler(
player, response, AlertID.ALERT_ITEM_NOT_ENOUGH,
u"heroLevelUp:item(%s) playeritem(%s) useCount(%s) count(%s)" %
(playeritem.item_id, item_id, count, playeritem.count))
return response
total_xp += playeritem.item.number * count
playerhero.add_xp(total_xp, player=player)
player.update_hero(playerhero, True)
playerheroteam = player.heroteams.get(playerhero.warrior.hero.heroTeamId)
playerheroteam.update_score()
player.update_heroteam(playerheroteam, True)
if player.tutorial_id == Static.TUTORIAL_ID_ADD_XP_12:
player.tutorial_complete()
for item_id, count in items.items():
playeritem = player.items.get(item_id)
playeritem.sub(count, info=info)
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 paymentCheck(request, response):
player = request.player
order_id = getattr(request.logic_request, "orderId", 0)
order = get_order(order_id)
if not order:
raise ErrorException(
player, u"paymentCheck:order(%s) is not existed" % order_id)
if settings.LOCAL_DEBUG and not order.is_success:
yuanbo = get_yuanbo(order.yuanbo_id)
add_yuanbo, is_first = recharge_yuanbo(player,
yuanbo,
info="debug recharge")
order.yuanbo = add_yuanbo
order.price = yuanbo.price
order.is_first = is_first
order.success()
order.save()
if order.is_success:
result = True
diamond = order.yuanbo
is_first = order.is_first
else:
result = False
diamond = 0
is_first = False
response.common_response.player.set("vip", player.vip)
response.common_response.player.set("buyDiamondIds",
player.yuanboshop.to_dict())
response.logic_response.set("result", result)
response.logic_response.set("diamond", diamond)
response.logic_response.set("isFirst", is_first)
return response
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 guildSiegeBattleConfig(request, response):
"""
公会团战的配置
"""
player = request.player
heroIds = getattr(request.logic_request, "heroIds", [])
category = getattr(request.logic_request, "category", 0) # 上中下，1 2 3
group = getattr(request.logic_request, "group", 0) # 一组 二组，1 2
power = getattr(request.logic_request, "power", 0)
if (int(category) not in range(1, 4)) or (int(group) not in range(1, 3)):
raise ErrorException(
player,
u"guildSiegeBattleConfigGet: parameter is error, category(%s) or group(%s)"
% (category, group))
configinfo = get_guildsiegeconfiginfo_by_playerid(player.pk)
if not configinfo:
configinfo = create_guildsiegeconfiginfo(player.pk)
if category == 1:
configinfo.setLeftArmy(group, heroIds, power)
elif category == 2:
configinfo.setMiddleArmy(group, heroIds, power)
elif category == 3:
configinfo.setRightArmy(group, heroIds, power)
response.logic_response.set("configinfo", configinfo.to_dict())
return response
def equipAutoLevelUp(request, response):
"""
一键强化装备
"""
playerequip_id = getattr(request.logic_request, "playerEquipId", 0)
player = request.player
info = u"一键强化装备:%s" % playerequip_id
playerequip = player.equips.get(playerequip_id)
if not playerequip:
raise ErrorException(
player, u"equipAutoLevelUp:playerequip_id(%s) is not existed" %
playerequip_id)
# 策划修改需求2016.5.31 修改。
before_level = playerequip.level
delta_level = player.level * 2 - playerequip.level
max_equip_level = player.level * 2
for i in range(0, delta_level):
#if playerequip.level >= max_equip_level:
# AlertHandler(player, response, AlertID.ALERT_LEVEL_NOT_ENOUGH, u"equipLevelUp:playerequip_id(%s) level(%s) playerLevel(%s)" % (playerequip_id, playerequip.level, player.level))
# return response
next_equipenhance = get_equipenhance(playerequip.level + 1)
equipenhance = get_equipenhance(playerequip.level)
#对应英雄更新
if not next_equipenhance:
break
if player.gold >= equipenhance.gold:
player.sub_gold(equipenhance.gold, info)
else:
break
playerequip.level_up(player, 1)
after_level = playerequip.level
ActionLogWriter.equip_enhance(player,
playerequip.pk,
playerequip.equip_id,
before_level,
after_level,
info=info)
player.dailytask_going(Static.DAILYTASK_CATEGORY_ENHANCE,
number=1,
is_incr=True,
is_series=False)
#强化大师检查
if playerequip.playerhero_id > 0:
playerhero = player.heroes.get(playerequip.playerhero_id)
if playerhero.check_equip_enhancemaster():
player.update_hero(playerhero, True)
player.update_equip(playerequip, True)
if player.tutorial_id == Static.TUTORIAL_ID_EQUIP_ENHANCE_6:
player.tutorial_complete()
return response
def guildShopBuy(request, response):
"""
公会商店购买
"""
player = request.player
shopId = getattr(request.logic_request, "shopId", 0)
info = u"公会商店购买"
# 获取商店的信息。
guildShop = get_guildshop(shopId)
if not player.guildshop.can_buy(shopId):
return response
if player.guild.gold < guildShop.cost:
AlertHandler(
player, response, AlertID.ALERT_GUILD_GOLD_NOT_ENOUGH,
u"guildShopBuy need guild_gold %s now player has %s" %
(guildShop.cost, player.guild.gold))
return response
player.guildshop.buy(shopId)
if guildShop.is_item:
acquire_item(player,
guildShop.itemId,
number=guildShop.count,
info=info)
elif guildShop.is_equipfragment:
acquire_equipfragment(player,
guildShop.itemId,
guildShop.count,
info=info)
elif guildShop.is_artifactfragment:
acquire_artifactfragment(player,
guildShop.itemId,
number=guildShop.count,
info=info)
elif guildShop.is_soul:
acquire_soul(player, guildShop.itemId, guildShop.count, info=info)
else:
raise ErrorException(
player,
u"mysteryShopBuy:arenashop(%s) is error" % (guildShop.itemId))
player.guild.sub_gold(guildShop.cost, info=info)
rewards = []
rewards.append({"type": guildShop.itemId, "count": guildShop.count})
response.common_response.player.set("guild", player.guild.to_dict())
response.common_response.player.set("guildShop",
player.guildshop.to_dict())
response.logic_response.set("rewards", rewards)
return response
def buildingPlantBuild(request, response):
"""
创建植物
"""
centerX = getattr(request.logic_request, "centerX", 0)
centerY = getattr(request.logic_request, "centerY", 0)
building_id = getattr(request.logic_request, "buildingId", -1) # building 表主键
player = request.player
buildingplant = get_buildingplant_by_buildingid(building_id)
if not buildingplant:
raise ErrorException(player, u"buildingBuild:plant(%s) is not existed" % building_id)
building = get_building(building_id)
#检查单个植物总数
building_count = get_building_count_by_level(building, player.castleLevel)
if building_count <= 0:
raise ErrorException(player, u"buildingBuild:plant(%s) create allow number is %s" % (building_id, building_count))
return response
playerbuilding_count = player.get_plants_count(buildingplant.pk)
if playerbuilding_count >= building_count:
AlertHandler(player, response, AlertID.ALERT_BUILDING_BUILD_OVER_MAX_NUMBER, u"buildingBuild:building(%s) create allow number is %s , already building number is %s" % (building_id, building_count, playerbuilding_count))
return response
#检查植物总数
vip = get_vip(player.vip_level)
if len(player.buildingplants.all()) >= vip.plantCount:
AlertHandler(player, response, AlertID.ALERT_BUILDING_BUILD_OVER_MAX_NUMBER, u"buildingBuild:building(%s) create allow number is %s , already building number is %s" % (building_id, vip.plantCount, len(player.buildingplants.all())))
return response
#创建消耗检查
costs = buildingplant.costs
for cost in costs:
playeritem = player.items.get(cost.type)
if not playeritem:
raise ErrorException(player, u"itemUse:playeritem(%s) no existed" % (playeritem.pk))
if not playeritem.can_sub(cost.count):
#更新数据
player.update_item(playeritem)
AlertHandler(player, response, AlertID.ALERT_ITEM_NOT_ENOUGH, u"itemUse:item(%s) playeritem(%s) useCount(%s) count(%s)" % (playeritem.item_id,cost.type, cost.count, playeritem.count))
return response
playeritem.sub(cost.count, u"物品使用")
info = u"创建植物"
playerbuildingplant = acquire_buildingplant(player, buildingplant, centerX = centerX, centerY = centerY, status = 0, buildingId = building_id)
ActionLogWriter.building_create(player, playerbuildingplant.pk, playerbuildingplant.plantId, info)
return response
def instanceSetUp(request, response):
'''
请求敌军信息
'''
player = request.player
level_id = getattr(request.logic_request, "instanceId", 0)
version = getattr(request.logic_request, "version", 0)
data = {}
instancelevel = get_instancelevel(level_id)
playerinstancelevel = player.instancelevels.get(level_id)
#副本
if not playerinstancelevel:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_NOT_OPEN, u"instanceSetUp:instance(%s) is not open" % level_id)
return response
if instancelevel.minUserLevel > player.level:
AlertHandler(player, response, AlertID.ALERT_LEVEL_SHORTAGE, u"instanceSetUp:instance(%s) level is %s and playerLevel is %s" % (level_id, instancelevel.minUserLevel, player.level))
return response
if playerinstancelevel.succeedCount >= instancelevel.maxPlayCount:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_FIGHT_COUNT_EXCEED_MAX, u"instanceSetUp:instance(%s) fight count(%s) exceed max count(%s)" % (level_id, playerinstancelevel.succeedCount, instancelevel.maxPlayCount))
return response
#体力不足
if player.power < instancelevel.powerCost:
AlertHandler(player, response, AlertID.ALERT_POWER_NOT_ENOUGH, u"instanceSetUp:power error (%s)" % player.power)
return response
enemies = instancelevel.enemies
if not enemies:
raise ErrorException(player, u"instanceSetUp: enemyData(%s) is not existed" % level_id)
# 这个打完boss的剧情以后进行的赋值 状态为400，并且完成,200进400出
if player.tutorial_id == Static.TUTORIAL_ID_INIT_1:
player.tutorial_begin()
# 这里的firstIn是选名字的新手引导。如果一进游戏提示你选名字是因为这个没有置成０
player.set("firstIn", 0)
if player.tutorial_id == Static.TUTORIAL_ID_INSTANCE_1ST_3:
player.tutorial_complete()
# 一请求副本就把新手引导的状态关闭掉。防止断线以后游戏会卡主
elif player.tutorial_id == Static.TUTORIAL_ID_HEROCOMPOSE2_11:
player.tutorial_complete()
# 这里做的奖励提前展示，结算后会把展示的奖励发放出去
rewards = playerinstancelevel.make_rewards_before_fight()
player.update_instancelevel(playerinstancelevel, True)
response.logic_response.set("rewards", rewards)
response.logic_response.set("enemies", [enemy.to_dict() for enemy in enemies])
response.logic_response.set("version", version)
return response
def equipCompose(request, response):
"""
装备碎片合成装备
"""
fragment_id = getattr(request.logic_request, "fragmentId", 0)
player = request.player
info = u"合成装备:%s" % fragment_id
fragment = get_equipfragment(fragment_id)
if not fragment:
raise ErrorException(
player, u"equipCompose:fragment(%s) is not existed" % fragment_id)
equip = get_equip(fragment.equipId)
if not equip:
raise ErrorException(
player,
u"equipCompose:equip(%s) is not existed" % fragment.equipId)
playerfragment = player.equipfragments.get(fragment.pk)
if not playerfragment or not playerfragment.can_sub(fragment.composeCount):
if not playerfragment:
player.delete_equipfragment(fragment_id)
else:
player.update_equipfragment(playerfragment)
AlertHandler(
player, response, AlertID.ALERT_EQUIP_COMPOSE_FRAGMENT_NOT_ENOUGH,
u"equipCompose:fragment(%s) composeCount(%s)" %
(fragment_id, fragment.composeCount))
return response
player.seven_days_task_going(Static.SEVEN_TASK_CATEGORY_EQUIP_COMPOSE,
number=1,
is_incr=True,
with_top=False,
is_series=True)
player.update_equipfragment(playerfragment)
playerfragment.sub(fragment.composeCount, info=info)
playerequip = acquire_equip(player, fragment.equipId, info=info)
response.logic_response.set("playerEquipId", playerequip.pk)
return response
def buildingPlantDismantle(request, response):
"""
植物铲除
"""
player = request.player
playerplant_id = getattr(request.logic_request, "playerPlantId", 0)
playerplant = player.buildingplants.get(playerplant_id)
if not playerplant:
raise ErrorException(player, u"plantDismantle:no playerbuildingplant(%s)" % (playerplant_id))
player.delete_buildingplant(playerplant_id, True)
return response
def _equipDown(request, response):
"""
卸下装备
"""
pos = getattr(request.logic_request, "pos", 0)
playerhero_id = getattr(request.logic_request, "playerHeroId", 0)
player = request.player
#检查英雄
playerhero = player.heroes.get(playerhero_id)
if not playerhero:
raise ErrorException(
player,
u"_equipDown:playerhero_id(%s) is not existed" % playerhero_id)
pos = int(pos)
#位置1~4 5,6为神器
if not (1 <= pos <= 4):
raise ErrorException(
player, u"_equipDown:playerhero_id(%s) pos(%s) is error" %
(playerhero_id, pos))
playerequip_id = playerhero.get_equip(pos)
playerequip = player.equips.get(playerequip_id)
#检查装备
if not playerequip:
raise ErrorException(
player,
u"_equipDown:playerhero_id(%s) pos(%s) playerequip(%s) is not existed"
% (playerhero_id, pos, playerequip_id))
#对应英雄更新
playerhero.set_equip(pos, 0)
player.update_hero(playerhero, True)
#对应装备更新
playerequip.playerhero_id = 0
player.update_equip(playerequip, True)
return response
def elementTowerChoiceBuff(request, response):
"""
元素之塔选择BUFF
"""
player = request.player
index = list(set(getattr(request.logic_request, "index", [0]))) #0 放弃 1-3 3个buff
if not player.elementTower.isInSweep:
if not player.elementTower.buffCanChoice:
raise ErrorException(player, u"elementTowerChoiceBuff levelStatus(%s) is error" % player.elementTower.levelStatus)
if 0 not in index:
costStar = 0
for i in index:
costStar += Static.ELEMENTTOWER_CHOCIE_BUFF_COSTS[i - 1]
#星星数量不足
if player.elementTower.star < costStar:
response.common_response.player.set("elementTower", player.elementTower.to_dict())
return response
player.elementTower.sub_star(costStar)
player.elementTower.choiceBuff(index)
else:
if "buffLevelIds" not in player.elementTower.sweepInfo or len(player.elementTower.sweepInfo["buffLevelIds"]) == 0:
raise ErrorException(player, u"elementTowerChoiceBuff sweep not box can choice")
if 0 not in index:
costStar = 0
for i in index:
costStar += Static.ELEMENTTOWER_CHOCIE_BUFF_COSTS[i - 1]
#星星数量不足
if player.elementTower.star < costStar:
response.common_response.player.set("elementTower", player.elementTower.to_dict())
return response
player.elementTower.sub_star(costStar)
player.elementTower.choiceSweepBuff(index)
response.common_response.player.set("elementTower", player.elementTower.to_dict())
return response
def elementTowerOpen(request, response):
'''
元素之塔开启
'''
towerId = getattr(request.logic_request, "towerId", -1)
player = request.player
towerInstance = get_elementtowerinstance(towerId)
if not towerInstance:
raise ErrorException(player, u"elementTowerOpen towerId(%s) is error" % towerId)
if player.level < towerInstance.minUserLevel:
raise ErrorException(player, u"elementTowerOpen towerId(%s) level(%s) is error" % (towerId, player.level))
if player.elementTower.towerId > 0:
raise ErrorException(player, u"elementTowerOpen towerId(%s) is opened" % (player.elementTower.towerId))
player.elementTower.open(towerId)
response.common_response.player.set("elementTower", player.elementTower.to_dict())
return response
def instanceReset(request, response):
'''
刷新副本次数
'''
#type = 1 普通 2 精英
player = request.player
level_id = getattr(request.logic_request, "instanceId", 0)
category = getattr(request.logic_request, "category", 0)
if category == 1:
isElite = False
instancelevel = get_instancelevel(level_id)
elif category == 2:
isElite = True
instancelevel = get_eliteinstancelevel(level_id)
else:
raise ErrorException(player, u"instance reset category error (%s)" % level_id)
if isElite:
playerinstancelevel = player.eliteinstancelevels.get(instancelevel.pk)
else:
playerinstancelevel = player.instancelevels.get(instancelevel.pk)
if not playerinstancelevel:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_NOT_OPEN, u"instanceReset:instance(%s) is not open" % level_id)
return response
vip = get_vip(player.vip_level)
if playerinstancelevel.refreshCount >= vip.resetElitInstanceCount:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_REFRESH_COUNT_EXCEED_MAX, u"instanceReset:instance(%s) refresh count(%s) exceed max(%s)" % (level_id, playerinstancelevel.refreshCount , vip.resetElitInstanceCount))
return response
cost_diamond = Static.REFRESH_INSTANCE_COST * (playerinstancelevel.refreshCount + 1)
if player.yuanbo < cost_diamond:
AlertHandler(player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH, u"instanceReset:instance(%s) refresh costDiamond(%s) playerDiamond(%s)" % (level_id, cost_diamond, player.yuanbo ))
return response
player.sub_yuanbo(cost_diamond, info=u"重置副本次数")
playerinstancelevel.refresh_count()
if isElite:
player.update_eliteinstancelevel(playerinstancelevel, True)
else:
player.update_instancelevel(playerinstancelevel, True)
return response
def artifactCompose(request, response):
"""
圣器合成
"""
artifact_id = getattr(request.logic_request, "artifactId", 0) #圣器碎片ID
info = u"合成圣器:%s" % artifact_id
player = request.player
#圣物合成需要该圣物的碎片
fragment = get_artifactfragment(artifact_id)
if not fragment:
raise ErrorException(
player,
u"artifactCompose:fragment(%s) is not existed" % artifact_id)
artifact = get_artifact(fragment.artifactId)
if not artifact:
raise ErrorException(
player, u"artifactCompose:artifact(%s) is not existed" %
fragment.artifactId)
playerfragment = player.artifactfragments.get(fragment.pk)
if not playerfragment or not playerfragment.can_sub(fragment.composeCount):
if not playerfragment:
player.delete_artifactfragment(artifact_id)
AlertHandler(
player, response,
AlertID.ALERT_ARTIFACT_COMPOSE_MATERIAL_NOT_ENOUGH,
u"artifactCompose:fragment(%s) composeCount(%s)" %
(artifact_id, fragment.composeCount))
return response
player.update_artifactfragment(playerfragment)
playerfragment.sub(fragment.composeCount, info=info)
playerartifact = acquire_artifact(player, fragment.artifactId, info=info)
response.logic_response.set("artifactId", playerartifact.pk)
return response
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 pvpDefenseArmy(request, response):
"""
设置防守阵容
"""
# playback_data = {}
player = request.player
category = getattr(request.logic_request, "category",
0) # 1,竞技场 2,攻城战英雄 3,攻城战英雄
defenseLayout = getattr(request.logic_request, "heroLayoutData", [])
defenseList = []
default_poses = Static.HERO_DEFENCE_POS
i = 0
for defenseheroid in defenseLayout[0:5]:
defenseList.append(defenseheroid)
defenseList.append(default_poses[i])
i += 1
if category == 1:
#竞技场的防守阵容
defenseHeroIds = []
player.defenseHeroLayout = defenseList
player.update_hero_defenseLayout(defenseList)
defenseHeroIds = player.defenseHeroLayout[0:len(player.
defenseHeroLayout):2]
player.defenseHeroIds = defenseHeroIds
player.update_hero_defenseHeroIds(defenseHeroIds)
response.common_response.player.set("defenseHeroIds", defenseHeroIds)
response.logic_response.set("state", 1)
elif category == 2:
#攻城战英雄的防守阵容
defenseSiegeIds = []
player.update_siege_defenseLayout(defenseList)
defenseSiegeIds = defenseList[0:len(player.defenseSiegeLayout):2]
player.update_siege_defenseHeroIds(defenseSiegeIds)
response.common_response.player.set("defenseSiegeIds", defenseSiegeIds)
elif category == 3:
#攻城战士兵的防守阵容
if len(defenseLayout) != len(player.defenseSiegeSoldierIds):
raise ErrorException(
player,
u"pvpDefenseArmy:pvp defense layout is incorrect: layout is %s"
% str(defenseLayout))
player.update_siege_defenseSoldierIds(defenseLayout)
response.common_response.player.set("defenseSiegeSoldierIds",
defenseLayout)
return response
def guildInstanceSetUp(request, response):
'''
请求敌军信息
'''
player = request.player
level_id = getattr(request.logic_request, "instanceId", 0)
guildInstancelevel = get_guildinstanceLevel(level_id)
guildInstancelevelInfo = get_sysguildinstanceInfo(level_id,player.guildId)
if not guildInstancelevelInfo or not guildInstancelevelInfo.isOpen:
if guildInstancelevelInfo:
guildInstancelevelInfo.self_release_lock()
AlertHandler(player, response, AlertID.ALERT_GUILD_INSTANCE_HAS_ALREADY_EXPIRED, u"guildInstanceSetUp this instacelevel has already expired")
return response
# 副本有人正在打
if guildInstancelevelInfo.isFighting > 0:
guildInstancelevelInfo.self_release_lock()
AlertHandler(player, response, AlertID.ALERT_GUILD_INSTANCE_IS_FIGHTING, u"guildInstanceSetUp somebody is in this instancelevel")
return response
# 已经打过这个副本一次了
if player.id in guildInstancelevelInfo.memberList:
guildInstancelevelInfo.self_release_lock()
AlertHandler(player, response, AlertID.ALERT_GUILD_INSTANCE_HAS_ALREADY_FIGHTED, u"guildInstanceSetUp this instacelevel has already fighted")
return response
enemies = guildInstancelevel.enemies
if not enemies:
guildInstancelevelInfo.self_release_lock()
raise ErrorException(player, u"instanceSetUp: enemyData(%s) is not existed" % level_id)
guildInstancelevelInfo.fight(player)
response.logic_response.set("bossHp", guildInstancelevelInfo.bossHp)
response.logic_response.set("bossPercentage", guildInstancelevelInfo.bossPercentage)
response.logic_response.set("enemies", [enemy.to_dict() for enemy in enemies])
return response
def equipDecompose(request, response):
"""
装备分解
"""
playerequip_ids = getattr(request.logic_request, "playerEquipIds", [])
player = request.player
rewards = []
refine_item_id = Static.ITEM_REFINE_ID
for playerequip_id in playerequip_ids:
playerequip = player.equips.get(playerequip_id)
if not playerequip:
raise ErrorException(
player, u"equipDecompose:playerequip_id(%s) is not existed" %
playerequip_id)
if not playerequip.can_decompose:
player.update_equip(playerequip)
AlertHandler(
player, response, AlertID.ALERT_EQUIP_CAN_NOT_DECOMPOSE,
u"equipDecompose： playerequip_id(%s) can not decompose" %
(playerequip_id))
return response
refinexp = playerequip.equip.decomposeRefinePoint
for i in range(0, playerequip.refineLevel):
equiprefine = get_equiprefine(playerequip.equip.quality, i)
refinexp += equiprefine.refineXp
info = u"装备分解:%s:%s" % (playerequip_id, playerequip.equip_id)
refinepoint = get_item(refine_item_id).number
number = refinexp / refinepoint
if number > 0:
acquire_item(player, refine_item_id, number=number, info=info)
rewards.append({"type": refine_item_id, "count": number})
player.delete_equip(playerequip_id, True)
ActionLogWriter.equip_delete(player, playerequip.pk,
playerequip.equip_id, info)
response.logic_response.set("rewards", rewards)
return response
def elementTowerReset(request, response):
'''
元素之塔重置
'''
player = request.player
if player.elementTower.towerId <= 0:
raise ErrorException(player, u"elementTowerReset tower is not opened")
if player.elementTower.refreshLeftCount > 0:
player.elementTower.reset(1)
elif player.elementTower.rewardCount > 0:
player.elementTower.reset(2)
elif player.elementTower.diamondLeftCount > 0:
cost = player.elementTower.diamondResetCost
if player.yuanbo < cost:
AlertHandler(player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH, u"elementTowerReset:playerDiamond(%s) costDiamond(%s) is not enough" % (player.yuanbo, cost))
return response
player.sub_yuanbo(cost, info=u"元素之塔重置")
player.elementTower.reset(3)
response.common_response.player.set("elementTower", player.elementTower.to_dict())
return response
def eliteInstanceSetUp(request, response):
'''
请求精英敌军信息
'''
player = request.player
eliteInstanceId= getattr(request.logic_request, "instanceId", 0)
eliteInstancelevel = get_eliteinstancelevel(eliteInstanceId)
playereliteinstancelevel = player.eliteinstancelevels.get(eliteInstanceId)
if not playereliteinstancelevel:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_NOT_OPEN, u"eliteInstanceSetUp:instance(%s) is not open" % eliteInstanceId)
return response
if playereliteinstancelevel.succeedCount >= eliteInstancelevel.eliteMaxPlayCount:
AlertHandler(player, response, AlertID.ALERT_INSTANCE_FIGHT_COUNT_EXCEED_MAX, u"eliteInstanceSetUp:instance(%s) fight count(%s) exceed max count(%s)" % (eliteInstanceId, playereliteinstancelevel.succeedCount, eliteInstancelevel.eliteMaxPlayCount))
return response
if player.power < eliteInstancelevel.elitePowerCost:
AlertHandler(player, response, AlertID.ALERT_POWER_NOT_ENOUGH, u"eliteInstanceSetUp:power error (%s)" % player.power)
return response
# 敌人的信息表里面已经配置好了，不出意外可以直接拿来使用
enemies = eliteInstancelevel.eliteEnemies
if not enemies:
raise ErrorException(player, u"eliteInstanceSetUp:levelid(%s) has not enemy" % eliteInstancelevel.id)
# 做的是奖励的提前展示，具体这部分代码，以下会详细说明
rewards = playereliteinstancelevel.make_elite_rewards_before_fight()
player.update_eliteinstancelevel(playereliteinstancelevel, True)
# 这里面添加了一个奖励的返回信息
response.logic_response.set("rewards", rewards)
response.logic_response.set("enemies", [enemy.to_dict() for enemy in enemies])
return response
def buildingSpeed(request, response):
"""
加速
"""
player = request.player
playerbuilding_id = getattr(request.logic_request, "playerBuildingId", 0)
playerbuilding = player.buildings.get(playerbuilding_id)
if not playerbuilding:
raise ErrorException(
player,
u"buildingSpeed:no playerbuilding(%s)" % (playerbuilding_id))
building_id = playerbuilding.building.pk
if playerbuilding.is_normal:
player.update_building(playerbuilding)
AlertHandler(
player, response, AlertID.ALERT_BUILDING_SPEED_CAN_NOT,
u"buildingSpeed:building(%s) playerbuilding(%s) status(%s) is normal"
% (building_id, playerbuilding_id, playerbuilding.status))
return response
#加速元宝数量检查
left_time = playerbuilding.timeLeft
delta_minute = int(math.ceil(left_time / 60.0))
yuanbo = 0.0 #加速消耗元宝
if delta_minute <= 60:
yuanbo = delta_minute * 2
elif delta_minute <= 600:
yuanbo = delta_minute * 1.7 + 18
else:
yuanbo = delta_minute * 1.2 + 318
yuanbo = int(math.ceil(yuanbo))
if yuanbo > player.yuanbo:
AlertHandler(
player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
u"buildingSpeed:building(%s) playerbuilding(%s) costYuanbo(%s) playerYuanbo(%s)"
% (building_id, playerbuilding_id, yuanbo, player.yuanbo))
return response
if playerbuilding.is_upgrading:
if playerbuilding.upgrade_over(speed=True):
if playerbuilding.building.is_castle:
player.update_castlelevel(playerbuilding.level)
if player.castleLevel == 3:
player.start_tutorial_by_id(
Static.TUTORIAL_ID_CASTLE_LEVELUP3_18)
elif player.castleLevel == 10 and player.isOpenSiege:
#开锁最后两个配置点
defenseSiegeSoldierIds = player.defenseSiegeSoldierIds
for i in range(0, 5, 4):
defenseSiegeSoldierIds[i] = 0
acquire_building(player,
1002003,
level=1,
centerX=i,
centerY=0,
status=0)
player.update_siege_defenseSoldierIds(
defenseSiegeSoldierIds)
response.common_response.player.set(
"defenseSiegeSoldierIds",
player.defenseSiegeSoldierIds)
if playerbuilding.building.is_hordebarrack:
player.update_hero_warriorIds(playerbuilding.building,
playerbuilding.level)
if player.tutorial_id == Static.TUTORIAL_ID_CASTLE_LEVELUP3_18:
player.tutorial_complete()
response.common_response.player.set("playerWarriorIds",
player.playerWarriorIds)
player.task_going(Static.TASK_CATEGORY_CASTLE_LEVELUP,
number=playerbuilding.level,
is_incr=False,
is_series=True)
player.update_building(playerbuilding, True)
player.sub_yuanbo(yuanbo,
info=u"加速升级:%s" % playerbuilding.building.name)
elif playerbuilding.is_producing:
if playerbuilding.producing_soldier(player, speed=True):
player.update_building(playerbuilding, True)
player.sub_yuanbo(yuanbo,
info=u"加速生产:%s" % playerbuilding.building.name)
response.common_response.player.set("playerWarriorIds",
player.playerWarriorIds)
response.common_response.player.set("populationCost",
player.populationCost)
return response
def buildingBuild(request, response):
'''
创建建筑
'''
centerX = getattr(request.logic_request, "centerX", 0)
centerY = getattr(request.logic_request, "centerY", 0)
building_id = getattr(request.logic_request, "buildingId", -1)
player = request.player
building = get_building(building_id)
if not building:
raise ErrorException(
player, u"buildingBuild:building(%s) is not existed" % building_id)
building_upgrade = get_building_upgrade_by_building_and_level(building, 0)
#能否升级等级检查
if not building_upgrade:
raise ErrorException(
player,
u"buildingBuild:building(%s) can not be created" % building_id)
if building.is_castle:
if building_upgrade.userLevel > player.level:
AlertHandler(
player, response, AlertID.ALERT_PLAYER_LEVEL_NOT_ENOUGH,
u"buildingBuild:building(%s) upgrade needlevel(%s) playerlevel(%s)"
% (building_id, building_upgrade.userLevel, player.level))
return response
elif building_upgrade.castleLevel > player.castleLevel:
AlertHandler(
player, response, AlertID.ALERT_BUILDING_CASTLE_LEVEL_NOT_ENOUGH,
u"buildingBuild:building(%s) upgrade needlevel(%s) playercastlelevel(%s)"
% (building_id, building_upgrade.castleLevel, player.castleLevel))
return response
#建造数量检查
building_count = get_building_count_by_level(building, player.castleLevel)
if building_count <= 0:
AlertHandler(
player, response, AlertID.ALERT_PLAYER_LEVEL_NOT_ENOUGH,
u"buildingBuild:building(%s) create allow number is %s" %
(building_id, building_count))
return response
#建造数量上限检查
playerbuilding_count = player.get_buildings_count(building.pk)
if playerbuilding_count >= building_count:
AlertHandler(
player, response, AlertID.ALERT_BUILDING_BUILD_OVER_MAX_NUMBER,
u"buildingBuild:building(%s) create allow number is %s , already building number is %s"
% (building_id, building_count, playerbuilding_count))
return response
#能否升级消耗检查
for cost in building_upgrade.costs:
if not reward_cost_check(player, cost):
if building.is_statue:
AlertHandler(
player, response,
AlertID.ALERT_BUILDING_MATERIAL_NOT_ENOUGH,
u"buildingBuild:building(%s) create cost(%s) is error" %
(building_id, cost.pk))
return response
AlertHandler(
player, response, AlertID.ALERT_BUILDING_MATERIAL_NOT_ENOUGH,
u"buildingBuild:building(%s) create cost(%s) is error" %
(building_id, cost.pk))
return response
#建造神像数量检查
if building.is_statue:
#神像总数的检查
vip = get_vip(player.vip_level)
if player.get_statue_count(building_id) >= vip.statueCount:
AlertHandler(
player, response, AlertID.ALERT_BUILDING_BUILD_OVER_MAX_NUMBER,
u"buildingBuild:building(%s) create allow number is %s , already building number is %s"
% (building_id, Static.STATUE_MAX_COUNT,
player.get_statue_count()))
return response
info = u"建造:%s" % building.name
for cost in building_upgrade.costs:
reward_cost(player, cost, info)
playerbuilding = acquire_building(player,
building,
centerX=centerX,
centerY=centerY,
status=0,
info=info)
#神像刚建造时
building_upgrade = get_building_upgrade_by_building_and_level(
playerbuilding.building, playerbuilding.level)
# 建造铁匠铺
if building.is_blacksmith:
if player.tutorial_id == Static.TUTORIAL_ID_BLACK_SMITH_5:
player.tutorial_complete()
player.next_tutorial_open()
# 建造金矿
if building.is_goldmine:
if player.tutorial_id == Static.TUTORIAL_ID_GOLDEN_7:
player.tutorial_complete()
player.next_tutorial_open()
# 建造伐木场
if building.is_loggingfield:
if player.tutorial_id == Static.TUTORIAL_ID_LOGFIELD_8:
player.tutorial_complete()
if building.is_tarven:
if player.tutorial_id == Static.TUTORIAL_ID_TAVERN_9:
player.tutorial_complete()
player.next_tutorial_open()
if building.is_arena:
if player.tutorial_id == Static.TUTORIAL_ID_ARENA_BUILD_17:
player.tutorial_complete()
player.setArenaOpen() #玩家可以被其他人搜索到
player.PVP.reset_daily_data()
player.arenashop.refresh_auto()
response.common_response.player.set("honorShop",
player.arenashop.to_dict())
response.common_response.player.set("arena", player.PVP.to_dict())
if building.is_elementtower:
player.elementTower.init()
response.common_response.player.set("elementTower",
player.elementTower.to_dict())
# 战争图腾建造 开启1700新手引导
if building.is_hordelab:
player.start_tutorial_by_id(Static.TUTORIAL_ID_INSTANCE_16)
# 上古遗迹建造 开启1800新手引导
if building.is_taitan:
player.start_tutorial_by_id(Static.TUTORIAL_ID_INSTANCE_17)
# 全视之眼建造 开启1900新手引导
if building.is_radar:
player.start_tutorial_by_id(Static.TUTORIAL_ID_INSTANCE_18)
player.setSiegeOpen() #玩家可以被其他人搜到
#城墙
acquire_building(player,
1002002,
level=1,
centerX=0,
centerY=0,
status=0,
info=info)
#城墙配置点
point = player.castleLevel < 10 and range(1, 4) or range(0, 5)
defenseSiegeSoldierIds = player.castleLevel < 10 and [-1, 0, 0, 0, -1
] or [
0, 0, 0, 0, 0
]
for i in point:
acquire_building(player,
1002003,
level=1,
centerX=i,
centerY=0,
status=0,
info=info)
#防御塔配置点
for i in range(2):
acquire_building(player,
1002004,
level=1,
centerX=i,
centerY=0,
status=0,
info=info)
player.update_siege_defenseSoldierIds(defenseSiegeSoldierIds)
response.common_response.player.set("defenseSiegeSoldierIds",
defenseSiegeSoldierIds)
response.common_response.player.set("siegeBattle",
player.SiegeBattle.to_dict())
return response
def buildingHarvest(request, response):
'''
采集
'''
player = request.player
playerbuilding_id = getattr(request.logic_request, "playerBuildingId", 0)
playerbuilding = player.buildings.get(playerbuilding_id)
diamond_harvest = 0
cal_proper = 33
if not playerbuilding:
raise ErrorException(
player,
u"buildingHarvest:no playerbuilding(%s)" % (playerbuilding_id))
if playerbuilding.building.is_goldmine:
# 金币收集有一定概率收集到 钻石。
count = playerbuilding.goldmine_compute()
# 收取金币随机收取一定量的钻石。具体方法超过最小采集上限，有百分之３０的概率获得金币
gold_mine = BuildingGolden.get_buildinggolden_by_building(
playerbuilding.building)
gold_mine = gold_mine[playerbuilding.level - 1]
if count > gold_mine.minHarvestScale and random.randint(
1, 100) <= cal_proper:
# 金币的收集数量和建筑物的等级有关系
diamond_harvest = random.choice(
range(playerbuilding.level, playerbuilding.level + 5))
player.add_yuanbo(diamond_harvest, info=u"收取金币随机奖励")
playerbuilding.goldmine_harvest()
player.add_gold(count, info=u"金矿采集")
player.task_going(Static.TASK_CATEGORY_GOLDENMINE_HARVEST,
number=count,
is_incr=True,
is_series=True)
elif playerbuilding.building.is_loggingfield:
count = playerbuilding.goldmine_compute()
playerbuilding.goldmine_harvest()
player.add_wood(count, info=u"木材采集")
player.task_going(Static.TASK_CATEGORY_WOOD_HARVEST,
number=count,
is_incr=True,
is_series=True)
elif playerbuilding.is_producing:
playerbuilding.producing_soldier(player)
response.common_response.player.set("soldiers",
player.armies.to_dict())
response.common_response.player.set("populationCost",
player.populationCost)
response.common_response.player.set("playerWarriorIds",
player.playerWarriorIds)
else:
player.update_building(playerbuilding)
AlertHandler(
player, response, AlertID.ALERT_BUILDING_HARVEST_CAN_NOT,
u"buildingHarvest:building(%s) playerbuilding(%s) can not harvest"
% (playerbuilding.building_id, playerbuilding_id))
return response
player.update_building(playerbuilding, True)
response.logic_response.set("diamondCount", diamond_harvest)
response.logic_response.set("playerBuildingId", playerbuilding_id)
return response
def buildingProduce(request, response):
"""
生产兵 升级兵
"""
player = request.player
datas = getattr(request.logic_request, "buildings", [])
# population = player.population
# used_population = player.populationCost
# _d["key"]玩家身上的建筑ｉｄ，并非建筑物ｉｄ
for _d in datas:
playerbuilding = player.buildings.get(_d["key"])
if not playerbuilding:
raise ErrorException(
player, u"buildingProduce:no playerbuilding(%s)" % (_d["key"]))
building_id = playerbuilding.building.pk
# 如果不是正常状态提示玩家，建筑正在工作.
if not playerbuilding.is_normal:
if playerbuilding.is_upgrading:
alert_id = AlertID.ALERT_BUILDING_IS_UPGRADING
elif playerbuilding.is_producing:
alert_id = AlertID.ALERT_BUILDING_IS_PRODUCING
player.update_building(playerbuilding)
AlertHandler(
player, response, alert_id,
u"buildingProduce:building(%s) produce playerbuilding(%s) status(%s) is not normal"
% (building_id, playerbuilding.id, playerbuilding.status))
return response
_production_level = 100
for _d in datas:
playerbuilding = player.buildings.get(_d["key"])
playerbuilding.produce_soldier_begin()
sort = 1
# 通过建筑ｉｄ获取建筑产出物
_productions = get_buildingproductions_by_building(
playerbuilding.building)
for _p in _d["productions"]:
_production = None
warrior = get_card(_p["production"]).warrior
for _pp in _productions:
for warrinfo in player.playerWarriorIds:
if warrinfo['soldierId'] == _p["production"]:
_production_level = warrinfo['soldierLevel']
if _pp.buildingLevel <= playerbuilding.level and _pp.productionId == _p[
"production"] and _pp.productionLevel == _production_level:
_production = _pp
break
if not _production:
AlertHandler(
player,
response,
Static.ALERT_BUILDING_HORDELAB_LEVEL_NOT_ENOUGH,
)
return response
playerbuilding.produce_soldier(_p["production"],
_p["productionCount"], _production,
sort)
if _production.is_drill:
info = u"训练：%s" % warrior.name
else:
info = u"升级：%s->%s" % (warrior.name,
player.armies.level(_p["production"]))
for cost in _production.cost:
reward_cost(player, cost, info, number=_p["productionCount"])
sort += 1
playerbuilding.produce_soldier_end()
player.update_building(playerbuilding, True)
response.common_response.player.set("populationCost",
player.populationCost)
response.common_response.player.set("playerWarriorIds",
player.playerWarriorIds)
return response
def buildingCheck(request, response):
'''
建筑物升级结束
'''
player = request.player
playerbuilding_id = getattr(request.logic_request, "playerBuildingId", 0)
playerbuilding = player.buildings.get(playerbuilding_id)
if not playerbuilding:
raise ErrorException(
player,
u"buildingCheck:no playerbuilding(%s)" % (playerbuilding_id))
building_id = playerbuilding.building.pk
if not playerbuilding.is_upgrading:
player.update_building(playerbuilding)
AlertHandler(
player, response, AlertID.ALERT_BUILDING_IS_NOT_UPGRADING,
u"buildingCheck:building(%s) harvest playerbuilding(%s) status(%s) is not normal"
% (building_id, playerbuilding_id, playerbuilding.status))
return response
if playerbuilding.upgrade_over():
player.update_building(playerbuilding, True)
else:
raise ErrorException(
player,
u"buildingCheck:building(%s) harvest playerbuilding(%s) is not over"
% (building_id, playerbuilding_id))
if playerbuilding.building.is_hordebarrack:
player.update_hero_warriorIds(playerbuilding.building,
playerbuilding.level)
response.common_response.player.set("playerWarriorIds",
player.playerWarriorIds)
if playerbuilding.building.is_castle:
player.update_castlelevel(playerbuilding.level)
# 当要塞升到三级，开启1600
if player.castleLevel == 2 and player.tutorial_id == Static.TUTORIAL_ID_CASTLE_LEVELUP_16:
player.next_tutorial_open()
elif player.castleLevel == 3:
player.start_tutorial_by_id(Static.TUTORIAL_ID_CASTLE_LEVELUP3_18)
elif player.castleLevel == 10 and player.isOpenSiege:
#开锁最后两个配置点
defenseSiegeSoldierIds = player.defenseSiegeSoldierIds
for i in range(0, 5, 4):
defenseSiegeSoldierIds[i] = 0
acquire_building(player,
1002003,
level=1,
centerX=i,
centerY=0,
status=0)
player.update_siege_defenseSoldierIds(defenseSiegeSoldierIds)
response.common_response.player.set("defenseSiegeSoldierIds",
player.defenseSiegeSoldierIds)
player.task_going(Static.TASK_CATEGORY_CASTLE_LEVELUP,
number=playerbuilding.level,
is_incr=False,
is_series=True)
return response