Exemple #1
0
def pvpCDTimeDelete(request, response):
    '''
    pvp 清除冷却时间
    '''

    # 在冷却的时间内不能进行战斗也不能进行刷新对手。如果想要做上述操作,需要先清除冷却的cd
    player = request.player

    #玩家没有到达PVP建筑开启等级
    if not player.isOpenArena:
        AlertHandler(
            player, response, AlertID.ALERT_LEVEL_SHORTAGE,
            u"pvpCDTimeDelete:playerLevel(%s) startLevel(%s)" %
            (player.level, Static.PVP_LEVEL))
        return response

    if player.yuanbo < Static.PVP_DELETE_CD_TIME_COST:
        AlertHandler(
            player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
            u"pvpCDTimeDelete cost(%s) now player have (%s)" %
            (Static.PVP_DELETE_CD_TIME_COST, player.yuanbo))
        return response

    player.PVP.cd_time = datetime.datetime.now()
    player.PVP.update()
    player.sub_yuanbo(Static.PVP_DELETE_CD_TIME_COST, info=u"清除PVP冷却时间")

    response.common_response.player.set("arena", player.PVP.to_dict())

    return response
Exemple #2
0
def eliteInstanceStart(request, response):
    '''
    精英结算
    '''
    player = request.player
    eliteInstancelevel_id = getattr(request.logic_request, "instanceId", 0)
    heroLayoutData = getattr(request.logic_request, "heroLayoutData", [])
    deadCount = 0
    isWin = getattr(request.logic_request, "isWin", False)
    summary = getattr(request.logic_request, "summary", {})

    elite_instancelevel = get_eliteinstancelevel(eliteInstancelevel_id)
    playereliteinstancelevel = player.eliteinstancelevels.get(eliteInstancelevel_id)

    #副本没有开启
    if not playereliteinstancelevel:
        AlertHandler(player, response, AlertID.ALERT_INSTANCE_NOT_OPEN, u"eliteInstanceStart:instance(%s) is not open" % eliteInstancelevel_id)
        return response


    if playereliteinstancelevel.succeedCount >= elite_instancelevel.eliteMaxPlayCount:
        AlertHandler(player, response, AlertID.ALERT_INSTANCE_FIGHT_COUNT_EXCEED_MAX, u"eliteInstanceStart:instance(%s) fight number(%s) exceed maxCount(%s)" % (eliteInstancelevel_id, playereliteinstancelevel.succeedCount, elite_instancelevel.eliteMaxPlayCount))
        return response

    #[玩家卡id, 卡id, 站位行, 列]
    player.update_hero_layout(heroLayoutData)

    if summary:
        leftWarriorDead = summary["leftWarriorDead"] #英雄小兵全部存在
        for i in range(0, len(leftWarriorDead), 2):
            if int(str(leftWarriorDead[i])[0:2]) == 11:
                deadCount += leftWarriorDead[i+1]

    # 默認三星,死一個兩星,其餘一星
    star = get_star(deadCount)

    data = playereliteinstancelevel.fight(star, isWin)
    if isWin:
        player.sub_power(elite_instancelevel.elitePowerCost)

    rewards = data["rewards"]
    heroLevelUp = data["heroLevelUp"]


    if isWin:
        # 策划修改,完成精英副本的时候,计算每日任务,既算完成一次普通副本,也算完成一次精英副本
        player.dailytask_going(Static.DAILYTASK_CATEGORY_ELIT_INSTANCE, number=1, is_incr=True, is_series=True)
        # 完成一个副本以后,进行任务值的添加
        player.task_going(Static.TASK_CATEGORY_ELIT_INSTANCE, number=1, c1=eliteInstancelevel_id, is_incr=False, is_series=False)
        player.dailytask_going(Static.DAILYTASK_CATEGORY_INSTANCE, number=1, is_incr=True, is_series=True)
    player.update_eliteinstancelevel(playereliteinstancelevel, True)

    response.logic_response.set("rewards", rewards)
    response.logic_response.set("heroLevelUp",heroLevelUp)
    response.logic_response.set("summary",summary)
    response.common_response.player.set("soldiers", player.armies.to_dict())
    response.common_response.player.set("populationCost", player.populationCost)
    response.logic_response.set("star", star)

    return response
Exemple #3
0
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
Exemple #4
0
def guildSiegeBattleEnter(request, response):
    """
    获取公会团战的报名
    """
    player = request.player

    #身份检查 只有会长和副会长才能报名
    if not player.guild.isChairman or not player.guild.isViChairman:
        # TODO:更换 AlertID
        AlertHandler(
            player, response, AlertID.ALERT_GUILD_LIMIT_NOT_ENOUGH,
            u"guildSiegeBattleEnter:only chairman or vice-chairman can sign up"
        )
        return response
    guildSiege = get_sysguildsiege()
    #检查公会战当前状态
    if not guildSiege.stage_sign_up:
        # TODO:更换 AlertID
        AlertHandler(
            player, response, AlertID.ALERT_GUILD_LIMIT_NOT_ENOUGH,
            u"guildSiegeBattleEnter:current stage can not be registered")
        return response
    #报名
    guildSiege.join(player.guildId)

    return response
Exemple #5
0
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
Exemple #6
0
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
Exemple #7
0
def guildFireStopBuff(request, response):
    """
    停止火堆燃烧
    """
    player = request.player

    fireIndex = getattr(request.logic_request, "index", 0)
    category = getattr(request.logic_request, "category", -1)

    if player.guild.isMember:
        AlertHandler(player, response, AlertID.ALERT_GUILD_LIMIT_NOT_ENOUGH,
                     u"guildFireStopBuff:only chairman can create fire")
        return response

    guildInfo = player.guild.guildInfo
    fire = getattr(guildInfo, "fire%s" % fireIndex)

    guildFire = guildInfo.get_fire_by_index(fireIndex)
    if not guildFire:
        guildInfo.self_release_lock()
        return response

    if not fire["buffLevel"]:
        AlertHandler(player, response, AlertID.ALERT_GUILD_FIRE_NOT_SET,
                     u"guildFireStopBuff:guild fire buff not set")
        return response

    if category == 0:
        guildInfo.stop_fire_buring(fireIndex)
    if category == 1:
        guildInfo.start_fire_buring(fireIndex)

    response.common_response.player.set("guild", player.guild.to_dict())

    return response
Exemple #8
0
def siegeBattleDelCDTime(request, response):
    """
    攻城战删除冷却时间
    """
    player = request.player
    # 检查等级
    if not player.isOpenSiege:
        AlertHandler(
            player, response, AlertID.ALERT_PLAYER_LEVEL_NOT_ENOUGH,
            u"siegeBattleDelCDTime:need level(%s) player level is %s" %
            (Static.SIEGE_LEVEL, player.level))
        return response
    if player.yuanbo < Static.SIEGE_DELETE_CD_TIME_COST:
        AlertHandler(
            player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
            u"siegeBattleDelCDTime cost(%s) now player have (%s)" %
            (Static.SIEGE_DELETE_CD_TIME_COST, player.yuanbo))
        return response

    player.SiegeBattle.reset_cdTime()
    player.SiegeBattle.update()
    player.sub_yuanbo(Static.SIEGE_DELETE_CD_TIME_COST, info=u"攻城战清除CD")
    response.common_response.player.set("siegeBattle",
                                        player.SiegeBattle.to_dict())

    return response
Exemple #9
0
def pvpResetCount(request, response):
    '''
    pvp
    '''
    player = request.player

    #玩家没有到达PVP建筑开启等级
    if not player.isOpenArena:
        AlertHandler(
            player, response, AlertID.ALERT_LEVEL_SHORTAGE,
            u"pvpOpps:playerLevel(%s) startLevel(%s)" %
            (player.level, Static.PVP_LEVEL))
        return response

    vip = get_vip(player.vip_level)

    if player.PVP.resetCount >= vip.resetPVPCount:
        AlertHandler(
            player, response, AlertID.ALERT_RESET_PVP_COUNT_NOT_ENOUGH,
            u"pvpResetCount:player pvpResetCount(%s) >= now VIP can have (%s)"
            % (player.PVP.resetCount, vip.resetPVPCount))
    needDiamond = player.PVP.resetCost

    if player.yuanbo < needDiamond:
        AlertHandler(
            player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
            u"pvpResetCount:player has (%s) reset PVP need (%s)" %
            (player.yuanbo, needDiamond))
        return response

    player.PVP.resetPVPCount()
    player.sub_yuanbo(needDiamond, info=u"竞技场重置")
    response.common_response.player.set("arena", player.PVP.to_dict())

    return response
Exemple #10
0
def siegeBattleFortReset(request, response):
    """
    攻城战堡垒信息重置
    """

    player = request.player
    fortIndexes = getattr(request.logic_request, "indexes", 0)

    # 检查等级
    if not player.isOpenSiege:
        AlertHandler(
            player, response, AlertID.ALERT_PLAYER_LEVEL_NOT_ENOUGH,
            u"siegeBattleFortReset:need level(%s) player level is %s" %
            (Static.SIEGE_LEVEL, player.level))
        return response

    diamondCost = player.SiegeBattle.reset_fort_cost
    for fortIndex in fortIndexes:
        if player.SiegeBattle.can_reset_fort(fortIndex - 1):
            print "OK"
            if player.yuanbo < diamondCost:
                AlertHandler(
                    player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
                    u"siegeBattleFortReset cost(%s) now player have (%s)" %
                    (diamondCost, player.yuanbo))
                return response
            player.sub_yuanbo(diamondCost, info=u"攻城战堡垒信息重置")
            player.SiegeBattle.reset_fort(fortIndex - 1)
            continue
    response.common_response.player.set("siegeBattle",
                                        player.SiegeBattle.to_dict())
    return response
Exemple #11
0
def createGuild(request, response):
    """
    创建社团
    """
    player = request.player
    # 如果玩家在社团内部那么他不可以再创建社团
    if player.guildId:
        AlertHandler(player, response, AlertID.ALERT_IS_IN_GUILD,
                     u"already in guild")
        return response
    # 钻石不足不可以创建社团
    if player.yuanbo < Static.CREATE_GUILD:
        AlertHandler(
            player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
            u"createGuild:need diamond(%s) player has %s" %
            (Static.CREATE_GUILD, player.yuanbo))
        return response
    # 等级不足不可以创建社团
    if player.level < Static.CREATE_GUILD_LEVEL:
        AlertHandler(
            player, response, AlertID.ALERT_LEVEL_SHORTAGE,
            u"createGuild:need level(%s) player level is  %s" %
            (Static.CREATE_GUILD_LEVEL, player.level))
    if player.guild.canJoinGuildAt > time.time():
        return response

    # 社团名字
    guildName = getattr(request.logic_request, "name", "")
    # 图标
    iconId = getattr(request.logic_request, "icon", 0)
    # 限制的等级
    limitLevel = getattr(request.logic_request, "limitLevel", 0)
    # 加入的类型,随意加,需审核,不允许
    category = getattr(request.logic_request, "category", 0)

    # 判断是否名字重复
    if get_guild_by_name(guildName):
        AlertHandler(player, response, AlertID.ALERT_GUILD_ALREADY_EXITS,
                     u"name already exits")
        return response

    # 创建社团
    player.guild.create_guild(guildName, iconId, limitLevel, category)
    player.sub_yuanbo(Static.CREATE_GUILD, info=u"创建公会")
    # 创建一级公会的副本
    allGuildInstanceLevels = get_all_guildinstancelevels()
    for guildInstanceLevel in allGuildInstanceLevels:
        if guildInstanceLevel.guildLevelLimit == 1:
            sysGuildInstance = create_sysguildinstance(player,
                                                       guildInstanceLevel.pk)
    #player.joinGuild(guild.id, Static.GUILD_CHAIRMAN_POSITION)
    # 返回公会的信息

# info = make_guildInfo(guild)
# 更新信息,告诉前端
    response.common_response.player.set("guild", player.guild.to_dict(True))
    return response
Exemple #12
0
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是选名字的新手引导。如果一进游戏提示你选名字是因为这个没有置成0
        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
Exemple #13
0
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
Exemple #14
0
def startGuildAuc(request, response):
    """
    开始拍卖
    """
    # 这个接口的功能,一个玩家出价,拍卖商品,把价格信息更新到max  和 all里面。
    # max里面每次比较新的值和老的值如果新的值比较大,更新
    # all每次都会把数据插入到这个表里面
    from guild.tasks import task_balance_guildauctionmaxinfo

    price = abs(int(getattr(request.logic_request, "price", 0)))
    aucRewardId = int(getattr(request.logic_request, "aucRewardId", 0))

    player = request.player

    aucInfo = get_guildmaxinfo(aucRewardId)

    #itemallinfo = getitemallinfo(player.guildId, itemId, instanceId)

    # 这件商品拍卖时间到了,被删除掉。
    if not aucInfo or not aucInfo.isAuctioning:
        AlertHandler(player, response, AlertID.ALERT_AUCTION_HAS_CLOSED, u"")

    else:
        if price > aucInfo.auctionReward.maxPrice:
            price = aucInfo.auctionReward.maxPrice

        if aucInfo.isOffer(player.id):
            AlertHandler(player, response, AlertID.ALERT_AUCTION_HAS_AUCED,
                         u"")
        elif price > player.guild.gold:
            AlertHandler(
                player, response, AlertID.ALERT_GUILD_GOLD_NOT_ENOUGH,
                u"startGuildAuc need guild_gold %s now player has %s " %
                (price, player.guild.gold))
        else:
            info = u"拍卖"
            player.guild.sub_gold(price, info)
            aucInfo.auction(player, price)
            if not aucInfo.isAuctioning:
                task_balance_guildauctionmaxinfo.delay(aucInfo.id)  #异步发奖
    aucInfos = []

    #TODO没有instanceId 从mongo里面读取
    maxinfos = get_guildauctionmaxinfos(player.guildId)
    for maxinfo in maxinfos:
        aucInfos.append(maxinfo.to_dict())

    response.common_response.player.set("guild", player.guild.to_dict())
    response.logic_response.set("aucInfos", aucInfos)

    return response
Exemple #15
0
def guildReName(request, response):
    """
    社团名变更
    """
    player = request.player

    param = getattr(request.logic_request, "name", "")
    level = getattr(request.logic_request, "level", 0)
    category = getattr(request.logic_request, "category",
                       -1)  # 1修改名字2修改头像3修改加入权限和等级

    ##if not player.guild.isChairman:
    if player.guild.isMember:
        return response

    guildInfo = player.guild.guildInfo

    if category == 1:
        if player.yuanbo < Static.RENAME_GUILD:
            guildInfo.self_release_lock()
            AlertHandler(
                player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
                u"guildReName:need diamond(%s) player has %s" %
                (Static.RENAME_GUILD, player.yuanbo))
            return response

        if get_guild_by_name(param):
            guildInfo.self_release_lock()
            AlertHandler(player, response, AlertID.ALERT_GUILD_ALREADY_EXITS,
                         u"name already exits")
            return response

        guildInfo.change_name(param)
        guildInfo.save()
        player.sub_yuanbo(Static.RENAME_GUILD, info=u"公会改名")

    elif category == 2:
        guildInfo.change_icon(param)
        guildInfo.save()
    elif category == 3:
        if param:
            guildInfo.change_category(int(param))
        if level:
            guildInfo.change_limitLevel(int(level))
        guildInfo.save()

    else:
        guildInfo.self_release_lock()

    response.common_response.player.set("guild", player.guild.to_dict())
    return response
Exemple #16
0
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
Exemple #17
0
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
Exemple #18
0
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
Exemple #19
0
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
Exemple #20
0
def siegeBattlePlayer(request, response):
    """
    搜索攻城战对手
    """
    player = request.player
    category = getattr(request.logic_request, "category",
                       0)  # 默认0正常匹配 1为确定取消保护再匹配

    if not player.isOpenSiege:
        AlertHandler(
            player, response, AlertID.ALERT_PLAYER_LEVEL_NOT_ENOUGH,
            u"siegeBattlePlayer:need level(%s) player level is %s" %
            (Static.SIEGE_LEVEL, 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 not player.SiegeBattle.has_truck:
        AlertHandler(player, response,
                     AlertID.ALERT_SIEGE_BATTLE_TRUCK_COUNT_IS_TOP,
                     u"siegeBattlePlayer:truck count is top")
        return response
    if player.siege_in_safed:
        # 处于被保护阶段
        if category == 1:
            player.cancel_protect_time()
        else:
            response.logic_response.set("hasSafeTime", True)
            return response
    # 不释放上一个对手的话30秒自动过期
    opp = player.SiegeBattle.searchOpp()
    if opp.id > 0:
        resource = opp.SiegeBattle.get_resources()  # 能被抢夺的资源
        opp.siege_be_searched()  # 设置被搜到
    else:
        resource = get_robot_resource(opp.id)
    response.logic_response.set("resources", resource)
    response.logic_response.set("opp", opp.siege_view_data())
    response.common_response.player.set("siegeBattle",
                                        player.SiegeBattle.to_dict())
    return response
Exemple #21
0
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
Exemple #22
0
def guildInstanceBook(request, response):
    """
    公会副本飞鸽传书  & bookType 0 为一键提醒  其他为关闭此副本的提醒
    """
    player = request.player
    instanceId = getattr(request.logic_request, "instanceId", 0)
    bookType = getattr(request.logic_request, "bookType", 0)

    if bookType == 1:
        if str(player.id) in player.guild.guildInfo.feiBookDict:
            if str(instanceId) in player.guild.guildInfo.feiBookDict[str(player.id)]:
                del player.guild.guildInfo.feiBookDict[str(player.id)][str(instanceId)]
                player.guild.guildInfo.save()
        return response
    #会长
    if not player.guild.isChairman:
        # TODO:更换 AlertID
        AlertHandler(player, response, AlertID.ALERT_GUILD_LIMIT_NOT_ENOUGH, u"guildInstanceBook:only chairman or vice-chairman can send feiBook")
        return response

    # if not instanceId or (bookType and not to_player_id):

    # 取得公会副本的信息
    sysGuildInstanceInfo = get_sysguildinstanceInfo(instanceId, player.guildId)
    if not sysGuildInstanceInfo or not sysGuildInstanceInfo.canFeiBook:
        if sysGuildInstanceInfo:
            sysGuildInstanceInfo.self_release_lock()
        AlertHandler(player, response, AlertID.ALERT_GUILD_INSTANCE_HAS_ALREADY_EXPIRED, u"guildInstanceBook this instacelevel has already expired")
        return response


    if not sysGuildInstanceInfo or not sysGuildInstanceInfo.isOpen:
        if sysGuildInstanceInfo:
            sysGuildInstanceInfo.self_release_lock()
        AlertHandler(player, response, AlertID.ALERT_GUILD_INSTANCE_HAS_ALREADY_EXPIRED, u"guildInstanceBook this instacelevel has already expired")
        return response

    pid_list = sysGuildInstanceInfo.get_unFighting_member_list()
    for player_id in pid_list:
        if str(player_id) not in player.guild.guildInfo.feiBookDict:
            player.guild.guildInfo.feiBookDict[str(player_id)] = {str(instanceId): int(time.time())}
        elif instanceId not in player.guild.guildInfo.feiBookDict[str(player_id)].keys():
            player.guild.guildInfo.feiBookDict[str(player_id)][str(instanceId)] = int(time.time())
    # response.logic_response.set("configinfo", configinfo.to_dict())
    return response
Exemple #23
0
def heroCompose(request, response):
    """
    灵魂碎片合成英雄
    """
    player = request.player
    soul_id = getattr(request.logic_request, "soulId", 0)
    info = u"灵魂碎片合成英雄"

    soul = get_soul(soul_id)

    playersoul = player.souls.get(soul_id)
    if not playersoul or not playersoul.can_sub(soul.recruitCost):
        if not playersoul:
            player.delete_soul(soul_id)
        else:
            player.update_soul(playersoul)
        AlertHandler(
            player, response,
            AlertID.ALERT_HERO_COMPOSE_SOUL_NUMBER_NOT_ENOUGH,
            u"heroCompose:soul(%s) recruitCost(%s)" %
            (soul_id, soul.recruitCost))
        return response

    playerhero = player.heroes.get(soul.recruitHeroId)
    if playerhero:
        player.update_hero(playerhero)
        AlertHandler(
            player, response, AlertID.ALERT_HERO_ALREADY_EXSIT,
            u"heroCompose:soul(%s) recruitHeroId(%s) existed" %
            (soul_id, soul.recruitHeroId))
        return response

    playersoul.sub(soul.recruitCost, info=info)

    star = int(str(soul.warrior_id)[-2:])

    new_id = soul.warrior_id / 100 * 100

    acquire_hero(player, new_id, info=info, star=star)

    if player.tutorial_id == Static.TUTORIAL_ID_HEROCOMPOSE_10:
        player.tutorial_complete()
        player.next_tutorial_open()

    return response
Exemple #24
0
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
Exemple #25
0
def guildLevelUp(request, response):
    """
    社团升级
    """
    player = request.player

    category = getattr(request.logic_request, "category", 0)

    # 金币捐献
    if not player.guild.isChairman and not player.guild.isViChairman:
        return response

    nextGuildLevel = get_guild(player.guild.guildInfo.level + 1)

    if not nextGuildLevel:
        return response

    guildLevel = get_guild(player.guild.guildInfo.level)
    if player.yuanbo < guildLevel.levelUpCost:
        AlertHandler(
            player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH,
            u"guildLevelUp need diamond %s you have %s" %
            (guildLevel.levelUpCost, player.yuanbo))
        return response

    #经验值不足
    if player.guild.guildInfo.xp < guildLevel.level:
        return response

    player.sub_yuanbo(guildLevel.levelUpCost, info=u"社团升级")
    player.guild.level_up(guildLevel)

    #公会升级后 添加相应的公会副本
    allGuildInstanceLevels = get_all_guildinstancelevels()  # 获取所有公会副本
    sysGuildInstances = get_sysguild_instances(player.guildId)  # 获取当前公会所有存在副本
    instanceIds = [i.instanceId for i in sysGuildInstances]
    for guildInstanceLevel in allGuildInstanceLevels:
        if player.guild.guildInfo.level >= guildInstanceLevel.guildLevelLimit and guildInstanceLevel.pk not in instanceIds:
            sysGuildInstance = create_sysguildinstance(player,
                                                       guildInstanceLevel.pk)
    #if player.guild.guildInfo.instanceIsOpen and not player.guild.guildInfo.createdInstance:
    #    allGuildInstanceLevels = get_all_guildinstancelevels()

    #    guildInfo = player.guild.guildInfo

    #    chairmanLastInstanceId  = player.lastInstance["lastLevelId"]
    #    lastInstanceLevel = get_instancelevel(chairmanLastInstanceId)
    #    for guildInstanceLevel in allGuildInstanceLevels:
    #如果是章节最后一关并且通关 or 当前章节没有通关
    #        if (lastInstanceLevel.levelIndex == 10 and player.lastInstance["lastFinished"] and int(str(chairmanLastInstanceId)[2:4]) >= guildInstanceLevel.id[2:4]) or int(str(chairmanLastInstanceId)[2:4]) > guildInstanceLevel.id[2:4]:
    #guildInfo.instanceIds.append(guildInstanceLevel.id)
    #            guildInfo.createdInstance = 1
    #            create_guildinstance(player, guildInstanceLevel.id)
    #            guildInfo.save()

    response.common_response.player.set("guild", player.guild.to_dict())
    return response
Exemple #26
0
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
Exemple #27
0
def guildInstanceOpen(request, response):
    '''
    开启公会副本
    '''
    player = request.player
    # 前端从静态表里面取出来公会副本的id
    instanceLevelId = getattr(request.logic_request, "instanceId", 0)
    guildInfo = player.guild.guildInfo

    # if not player.guild.guildInfo.instanceIsOpen:
    #     AlertHandler(player, response, AlertID.ALERT_GUILD_INSTANCE_LEVEL_LIMIT, u"guildInstanceOpen your guild level %s is limit" % player.guild.guildInfo.level)
    #     guildInfo.self_release_lock()
    #     return response
    # 在公会达到十级的时候就已经把所有的副本全部加入备选的方案了,只不过状态还是设置为未开启的状态

    # 普通成员没有权限开启副本
    if player.guild.isMember:
        guildInfo.self_release_lock()
        AlertHandler(player, response, AlertID.ALERT_GUILD_LIMIT_CAN_NOT_OPEN_INSTANCE, u"guildInstanceOpen your position is %s open instance need 2 or 1" %(player.guild.position))
        return response
    # 去静态表里面取得公会副本的信息
    sysGuildInstance = get_sysguildinstanceInfo(instanceLevelId, player.guildId)
    guildinstancelevel = get_guildinstanceLevel(instanceLevelId)

    if player.yuanbo < guildinstancelevel.diamondCost:
        AlertHandler(player, response, AlertID.ALERT_DIAMOND_NOT_ENOUGH, u"guildInstanceOpen:instanceLevelId(%s)  melt costYuanbo(%s) playerYuanbo(%s)" % (instanceLevelId, guildinstancelevel.diamondCost, player.yuanbo))
        return response
    info = u"开启公会副本:%s:%s" % (player.guildId, instanceLevelId)
    player.sub_yuanbo(guildinstancelevel.diamondCost, info)


    if not sysGuildInstance or not  sysGuildInstance.isWaiting or player.guild.guildInfo.level < guildinstancelevel.guildLevelLimit:
        guildInfo.self_release_lock()
        if sysGuildInstance:
            sysGuildInstance.self_release_lock()
        response.logic_response.set("instanceInfo", sysGuildInstance.to_dict())
        return response
    sysGuildInstance.open()

    guildInfo.self_release_lock()
    response.logic_response.set("instanceInfo", sysGuildInstance.to_dict())

    return response
Exemple #28
0
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
Exemple #29
0
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
Exemple #30
0
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