Ejemplo n.º 1
0
    def timeLeft(self):
        over_time = 0
        if self.is_normal:
            if self.building.is_goldmine or self.building.is_loggingfield:
                over_time = delta_time(self.start_datetime)
        else:
            over_time = delta_time(datetime.datetime.now(), self.end_datetime)

        return over_time if over_time > 0 else 0
Ejemplo n.º 2
0
 def winTime(self):
     '''
     连胜剩余时间
     '''
     if self.serieWins:
         over_time = delta_time(self.serieWin_time)
         if over_time > Static.UPDATE_TIME_SERIE_WIN:
             self.serieWins = 0
             self.update()
         else:
             return Static.UPDATE_TIME_SERIE_WIN - over_time
     return 0
Ejemplo n.º 3
0
    def goldmine_compute(self):
        """
        金矿金币计算
        """
        storage = 0
        over_time = delta_time(self.start_datetime)
        golden_level = self.building.golden_levels[self.level]

        _gold = 0

        _gold = int(
            math.ceil(over_time / 3600.0 * golden_level.productionPerHour))

        if _gold > golden_level.storage:
            _gold = golden_level.storage

        return _gold
Ejemplo n.º 4
0
    def _handle(request, response):
        session_id = request.common_request.sessionId
        request.session = import_module(
            settings.SESSION_ENGINE).SessionStore(session_id)
        expiry_age = request.session.get_expiry_age()
        #print "expiry_age is %s"  % expiry_age

        #时间太久没有登陆,请重新登陆
        if expiry_age <= 0 or expiry_age > 3600:
            request.session.flush()
            response.common_response.set("success", False)
            response.common_response.set("errorCode",
                                         ErrorID.ERROR_LOGIN_TIMEOUT)
            return response

        #用户登陆错误
        if int(request.session.get('userid', 0)) != int(
                request.common_request.playerId):
            request.session.flush()
            response.common_response.set("success", False)
            response.common_response.set("errorCode",
                                         ErrorID.ERROR_LOGIN_ERROR_USER)
            return response

        #掉线重连检查
        timestamp = int(request.http_request.META.get("HTTP_TIMESTAMP", 0))
        if not timestamp:
            response.common_response.set("success", False)
            response.common_response.set("errorCode", ErrorID.ERROR_SIGN)
            return response

        if int(request.session["requestTimeStamp"]) == int(timestamp):
            return cPickle.loads(request.session["lastResponse"])

        player = get_player_by_userid(request.common_request.playerId,
                                      request.common_request.serverid)
        player.request = request
        player.response = response
        token = request.http_request.META.get("HTTP_TOKEN",
                                              "").replace("-", "").lower()
        seed = request.common_request.seed

        #设备在其他机器登陆
        if player.deviceId != request.common_request.deviceId:
            #print "player deviceId is %s and request deviceId is %s" % (player.deviceId, request.common_request.deviceId)
            response.common_response.set("success", False)
            response.common_response.set(
                "errorCode", ErrorID.ERROR_ACCOUNT_LOGIN_ON_OTHER_DEVICE)
            return response

        if not player.check_md5(seed) or md5.md5(
                request.request_body).hexdigest() != token:
            response.common_response.set("success", False)
            response.common_response.set("errorCode", ErrorID.ERROR_SIGN)
            return response
        player.use_md5Seed(seed)

        #封号检查
        now = datetime.datetime.now()
        if delta_time(now, player.banAt) > 1:
            #时间差大于1秒
            response.common_response.set("success", False)
            response.common_response.set("errorCode", ErrorID.ERROR_BANNED)
            return response

        if not request.logic_request.timeDelay:
            #yoyprint("check time delay")
            #加速器检查 or 修改时间检查
            client_time = int(request.common_request.clientTime)  #前端时间
            delta_server_time = int(time.time()) - player.server_time
            delta_client_time = client_time - player.client_time

            #修改时间
            if delta_client_time < 0 or player.current_client_time > client_time:
                response.common_response.set("success", False)
                response.common_response.set("errorCode",
                                             ErrorID.ERROR_TIME_CHANGED_ERROR)
                return response

            #用户使用加速器
            if delta_client_time - delta_server_time > 60:
                response.common_response.set("success", False)
                response.common_response.set("errorCode",
                                             ErrorID.ERROR_TIME_ERROR)
                return response

            player.set("current_client_time", client_time)

        request.player = player
        if player.tutorial[
                "guideGid"] == Static.TUTORIAL_ID_ELITE_INSTANCE and player.tutorial[
                    "status"] == 1:
            player.tutorial_complete()

        if request.common_request.powerRank:
            player.setPowerRank(request.common_request.powerRank)

        response = view_func(request, response)
        if request.common_request.maxFiveHeroPower > 0:
            player.seven_days_task_going(
                category=Static.SEVEN_TASK_CATEGORY_BATTLE_POWER,
                number=int(request.common_request.maxFiveHeroPower),
                is_incr=False,
                with_top=True,
                is_series=True)

        #整点请求
        now = datetime.datetime.now()
        next_hour = now + datetime.timedelta(seconds=3600)
        next_int_hour = datetime.datetime(next_hour.year, next_hour.month,
                                          next_hour.day, next_hour.hour)
        serverIntCDTime = (next_int_hour - now).total_seconds() + 1
        response.common_response.set("serverIntCDTime", int(serverIntCDTime))

        player.dailyCheck()
        #副本更新 普通副本 and 精英副本
        instancesDict = get_update_instance_dict(player)

        if instancesDict:
            response.common_response.player.set("instance", instancesDict)

        game_experiment = get_game_experiment()
        if int(game_experiment.values.get("vvv",
                                          -1)) != request.common_request.vvv:
            response.common_response.set(
                "vvv", int(game_experiment.values.get("vvv", 0)))
            response.common_response.player.set(
                "experiments",
                get_active_experiments(player).values())

        response.common_response.player.set("level", player.level)
        response.common_response.player.set("xp", player.xp)
        response.common_response.player.set("gold", player.gold)
        response.common_response.player.set("wood", player.wood)
        response.common_response.player.set("diamond", player.yuanbo)
        response.common_response.player.set("couragePoint",
                                            player.couragepoint)
        response.common_response.player.set("power", player.power)
        response.common_response.player.set("stamina", player.stamina)
        response.common_response.player.set("dailyTaskActivity",
                                            player.dailyTaskActivity)
        response.common_response.player.set("activityBoxIds",
                                            player.activityBoxIds)
        response.common_response.player.set("activityValue",
                                            player.activityValue)
        response.common_response.player.set("towerGold", player.towerGold)
        response.common_response.player.set("wallWarriorIds",
                                            player.wallWarriorIds)
        response.common_response.player.set("daysFromcreated",
                                            player.daysFromcreated)
        #response.common_response.player.set("fireBuff", player.fireBuff)
        response.common_response.player.set(
            "completeTaskList",
            [(int(taskId), status)
             for taskId, status in player.completeSevenTasks.items()])

        response.common_response.player.set("powerCDTime",
                                            player.next_power_time)
        response.common_response.player.set("staminaCDTime",
                                            player.next_stamina_time)
        response.common_response.player.set("weekCardLeftDay",
                                            player.week_card_left_day)
        response.common_response.player.set("monthCardLeftDay",
                                            player.month_card_left_day)
        response.common_response.player.set("permanentCardActivity",
                                            player.permanent_card_is_activity)
        response.common_response.player.set("hasUnReadMails",
                                            player.has_unread_mails)
        response.common_response.player.set("seeds", player.md5Seeds)
        response.common_response.player.set("safedTime", player.safedTime)
        response.common_response.set("serverTime", int(time.time()))
        if player.tutorial_change:
            response.common_response.player.set("tutorial", player.tutorial)

        if player.armies_change:
            player.response.common_response.player.set("soldiers",
                                                       player.armies.to_dict())

        if player.levelup and player.level == Static.PVP_LEVEL:
            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 player.levelup and player.level == Static.SIEGE_LEVEL:
            #player.SiegeBattle.refresh_auto()
            response.common_response.player.set("siegeBattle",
                                                player.SiegeBattle.to_dict())

        if player.PVP_change and player.isOpenArena:
            response.common_response.player.set("arena", player.PVP.to_dict())

        _modify_handler(request, response)
        request.session.set_expiry(3599)  #一个小时内没有登录token失效
        #用户数据保存
        player.update()
        #保存上一次操作数据
        request.session["requestTimeStamp"] = int(timestamp)
        request.session["lastResponse"] = cPickle.dumps(response)
        request.session.save()
        return response
Ejemplo n.º 5
0
def init(request, response):
    player = request.player

    player.init_md5Keys()  #初始化md5 seed
    #封号检查
    now = datetime.datetime.now()
    if delta_time(now, player.banAt) > 1:
        #时间差大于1秒
        response.common_response.set("success", False)
        response.common_response.set("errorCode", ErrorID.ERROR_BANNED)
        return response
    activities = get_activities()
    #更新所有奖励
    update_playeractivities(player)
    player.mysteryshop.refresh_auto()

    # player.guildshop.refresh_auto()

    playeritems = player.items.all().values()
    for playeritem in playeritems:
        player.update_item(playeritem)

    playerbuyrecords = player.buyrecords.all().values()
    for playerbuyrecord in playerbuyrecords:
        player.update_buyrecord(playerbuyrecord)

    #playerbuytowerrecords = player.buytowerrecords.all().values()
    #for playerbuytowerrecord in playerbuytowerrecords:
    #    player.update_buytowerrecord(playerbuytowerrecord)

    playerequips = player.equips.all().values()
    for playerequip in playerequips:
        player.update_equip(playerequip)

    playerequipfragments = player.equipfragments.all().values()
    for playerequipfragment in playerequipfragments:
        player.update_equipfragment(playerequipfragment)

    playerartifacts = player.artifacts.all().values()
    for playerartifact in playerartifacts:
        player.update_artifact(playerartifact)

    playerheroes = player.heroes.all().values()
    for playerhero in playerheroes:

        skillhero = get_heroskill(playerhero.warrior.cardId)
        for i in range(0, len(skillhero.skillinfo) / 3):
            skillGild, _, upgrade = skillhero.skillinfo[i * 3:(i + 1) * 3]
            if upgrade > playerhero.upgrade:
                setattr(playerhero, "skill%sLevel" % (i + 1), 0)
            else:
                if not getattr(playerhero, "skill%sLevel" % (i + 1), 0):
                    setattr(playerhero, "skill%sLevel" % (i + 1), 1)

        player.update_hero(playerhero, True)

    playerheroteams = player.heroteams.all().values()
    for playerheroteam in playerheroteams:
        playerheroteam.update_score()
        player.update_heroteam(playerheroteam, True)

    playersouls = player.souls.all().values()
    for playersoul in playersouls:
        player.update_soul(playersoul)

    playerbuildings = player.buildings.all().values()
    for playerbuilding in playerbuildings:
        playerbuilding.check_upgrade()
        player.update_building(playerbuilding)

    playerbuildingplants = player.buildingplants.all().values()
    for playerplant in playerbuildingplants:
        playerplant.check_status()
        player.update_buildingplant(playerplant)

    playerartifacts = player.artifacts.all().values()
    for playerartifact in playerartifacts:
        player.update_artifact(playerartifact)

    playerartifactfragments = player.artifactfragments.all().values()
    for playerartifactfragment in playerartifactfragments:
        player.update_artifactfragment(playerartifactfragment)

    playerbuildingfragments = player.buildingfragments.all().values()
    for playerbuildingfragment in playerbuildingfragments:
        player.update_buildingfragment(playerbuildingfragment)

    playeractivities = player.activities.all().values()
    for playeractivity in playeractivities:
        if playeractivity.activity.isOpen(player.userid):
            player.update_activity(playeractivity)

    for category, _ in player.dailyTasks.items():
        player.update_dailytask(category)

    for category, _ in player.tasks.items():
        player.update_task(category)

    for category, _ in player.dailyTasks.items():
        player.update_dailytask(category)

    for category, _ in player.sevenDaystasks.items():
        player.update_seven_days_task(category)

    if player.tutorial[
            "guideGid"] == Static.TUTORIAL_ID_ELITE_INSTANCE and player.tutorial[
                "status"] == 1:
        player.tutorial_complete()

    # 提前先更新,不然一会返回倒计时的时候会刷新时间
    #player.PVP.update_oppIds()

    #response.common_response.player.set("opps", sumOpps)
    response.common_response.player.set("dailyOppdata", get_yesterday_rank())
    response.common_response.player.set("weekOppdata", get_lastweek_rank())

    response.common_response.player.set("activityValue", player.activityValue)
    response.common_response.player.set("towerGold", player.towerGold)
    response.common_response.player.set("tavern", player.tavern)
    response.common_response.player.set("gold", player.gold)
    response.common_response.player.set("wood", player.wood)
    response.common_response.player.set("diamond", player.yuanbo)
    response.common_response.player.set("xp", player.xp)
    response.common_response.player.set("couragePoint", player.couragepoint)
    response.common_response.player.set("level", player.level)
    response.common_response.player.set("power", player.power)
    response.common_response.player.set("stamina", player.stamina)
    response.common_response.player.set("vip", player.vip)
    response.common_response.player.set("daysFromcreated",
                                        player.daysFromcreated)
    response.common_response.player.set("activityBoxIds",
                                        player.activityBoxIds)
    response.common_response.player.set(
        "completeTaskList",
        [(int(taskId), status)
         for taskId, status in player.completeSevenTasks.items()])
    response.common_response.player.set("dailyTaskActivity",
                                        player.dailyTaskActivity)
    response.common_response.player.set("halfBuyIds", player.halfBuyIds)
    #response.common_response.player.set("speedCount", player.speedCount)
    #response.common_response.player.set("beSpeededCount", player.beSpeededCount)
    response.common_response.player.set("powerCDTime", player.next_power_time)
    response.common_response.player.set("staminaCDTime",
                                        player.next_stamina_time)
    response.common_response.player.set("weekCardLeftDay",
                                        player.week_card_left_day)
    response.common_response.player.set("monthCardLeftDay",
                                        player.month_card_left_day)
    response.common_response.player.set("permanentCardActivity",
                                        player.permanent_card_is_activity)
    response.common_response.player.set("wallHp", player.wall_level)
    response.common_response.player.set("tutorial", player.tutorial)
    response.common_response.player.set("buyDiamondIds",
                                        player.yuanboshop.to_dict())
    response.common_response.player.set("hasUnReadMails",
                                        player.has_unread_mails)
    response.common_response.player.set("openDiamondShop",
                                        settings.OPEN_PAYMENT)
    response.common_response.player.set("mysteryShop",
                                        player.mysteryshop.to_dict())
    response.common_response.player.set("guildShop",
                                        player.guildshop.to_dict())
    response.common_response.player.set("guild",
                                        player.guild.to_dict(True, True))

    response.common_response.player.set("playerWarriorIds",
                                        player.playerWarriorIds)
    response.common_response.player.set("lastRaidId", player.lastRaidId)
    response.common_response.player.set("smallGameLeftTimes",
                                        player.smallGameLeftTimes)
    response.common_response.player.set("elementTower",
                                        player.elementTower.to_dict())
    response.common_response.player.set("offlinebonus", player.offlinebonus)
    response.common_response.player.set("wallWarriorIds",
                                        player.wallWarriorIds)
    response.common_response.player.set("safedTime", player.safedTime)

    #PVP
    if player.isOpenArena:
        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 player.isOpenSiege:
        # TODO: 攻城战刷新
        # player.SiegeBattle.refresh_auto()
        response.common_response.player.set("siegeBattle",
                                            player.SiegeBattle.to_dict())

    # fire = get_fireinfo_by_guildId(player.guildId)
    # if fire:
    #     fire = fire[0]
    #     make_fireInfo(fire)

    # response.common_response.player.set("fireBuff", player.fireBuff)

    response.common_response.player.set("userInfo", player.userSimple_dict())
    response.common_response.player.set("soldiers", player.armies.to_dict())

    if player.tutorial_id == Static.TUTORIAL_ID_INIT_1:
        player_tutorial_heroes = get_tutorial_heroes(player)

        response.common_response.player.set(
            "tutorialHeroes",
            [hero.to_dict() for hero in player_tutorial_heroes])
        enemies = get_instancelevel(1).enemies
        response.common_response.player.set(
            "enemies", [enemy.to_dict() for enemy in enemies])

    response.common_response.player.set("instance",
                                        get_player_view_instance_dict(player))
    response.common_response.player.set("starBox",
                                        {"history": player.starChest})
    response.common_response.player.set("eliteStarBox",
                                        {"history": player.eliteStarChest})
    response.common_response.player.set(
        "raidInstance", {"instances": get_player_open_raidinstance(player)})
    # response.common_response.player.set("waravoidCDTime", player.waravoidCDTime)
    response.common_response.player.set("seeds", player.md5Seeds)
    response.common_response.player.set("firstIn", player.firstIn)
    #整点请求
    now = datetime.datetime.now()
    next_hour = now + datetime.timedelta(seconds=3600)
    next_int_hour = datetime.datetime(next_hour.year, next_hour.month,
                                      next_hour.day, next_hour.hour)
    serverIntCDTime = (next_int_hour - now).total_seconds() + 1
    response.common_response.set("serverIntCDTime", int(serverIntCDTime))
    response.common_response.player.set("defenseHeroIds",
                                        player.defenseHeroIds)
    response.common_response.player.set("defenseSiegeIds",
                                        player.defenseSiegeIds)
    response.common_response.player.set("defenseSiegeSoldierIds",
                                        player.defenseSiegeSoldierIds)
    #zrd
    response.common_response.set(
        "activities", [activity.to_dict() for activity in activities])
    response.common_response.set("serverTime", int(time.time()))
    return response