Example #1
1
 def __isDelayPerformed(self):
     result = True
     if self._exitEntity and self._exitEntity.isSpeakOver():
         result = not self._sound.isPlaying(SOUND_EVENT.SPEAKING)
         if result:
             self._sound.setMuted(True)
             self._exitTime = BigWorld.time() + self._exitEntity.getFinishDelay()
             self._exitEntity = None
     if self._exitTime > 0:
         result = self._exitTime < BigWorld.time()
     return result
Example #2
0
 def groupDamages(self):
     isGroupRamming_WorldCollision = (data.data['attackReasonID'] in [2, 3]) and config.get(self.S_GROUP_DAMAGE_RAMMING_COLLISION)
     isGroupFire = (data.data['attackReasonID'] == 1) and config.get(self.S_GROUP_DAMAGE_FIRE)
     if isGroupRamming_WorldCollision or isGroupFire:
         dataLog = data.data.copy()
         attackerID = dataLog['attackerID']
         attackReasonID = dataLog['attackReasonID']
         if attackerID in self.dictVehicle:
             if attackReasonID in self.dictVehicle[attackerID]:
                 key = self.dictVehicle[attackerID][attackReasonID]
                 if ('time' in key) and ('damage' in key) and ((BigWorld.serverTime() - key['time']) < 1):
                     key['time'] = BigWorld.serverTime()
                     key['damage'] += dataLog['damage']
                     dataLog['damage'] = key['damage']
                     dataLog['dmgRatio'] = dataLog['damage'] * 100 // dataLog['maxHealth']
                     dataLog['fireDuration'] = BigWorld.time() - key['startAction'] if (attackReasonID == 1) and (key['startAction'] is not None) else None
                     dataLog['hitTime'] = key['hitTime']
             else:
                 self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
                                                                 'damage': dataLog['damage'],
                                                                 'startAction': BigWorld.time() if attackReasonID == 1 else None,
                                                                 'hitTime': dataLog['hitTime']}
                 dataLog['fireDuration'] = 0 if attackReasonID == 1 else None
         else:
             self.dictVehicle[attackerID] = {}
             self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
                                                             'damage': dataLog['damage'],
                                                             'startAction': BigWorld.time() if attackReasonID == 1 else None,
                                                             'hitTime': dataLog['hitTime']}
             dataLog['fireDuration'] = 0 if attackReasonID == 1 else None
         self.setOutParameters(dataLog)
     else:
         self.setOutParameters(data.data)
Example #3
0
 def sendCommand(self,controller,command):
     diff = IngameMessanger.cooldDown - BigWorld.time()
     if diff < 0:
         diff = 0
         IngameMessanger.cooldDown = BigWorld.time()
     IngameMessanger.cooldDown += IngameMessanger.myConf['CommandDelay']
     BigWorld.callback(diff, partial(controller.sendCommand,command)) 
Example #4
0
 def sendText(self,controller,text):
     diff = IngameMessanger.cooldDown - BigWorld.time()
     if diff < 0:
         diff = 0
         IngameMessanger.cooldDown = BigWorld.time()
     IngameMessanger.cooldDown += IngameMessanger.myConf['TextDelay']
     BigWorld.callback(diff,partial(controller._broadcast,text))
Example #5
0
 def _startLoopEvent(self):
     if BARREL_DEBUG_ENABLED:
         LOG_DEBUG('!!! {0} Start Loop = {1}'.format(BigWorld.time(), self._desc.startLoop))
         LOG_DEBUG('!!!Shell DT = {0}'.format(self.__shellDt))
     SoundGroups.g_instance.playSound2D(self._desc.startLoop)
     self._startLoopT = BigWorld.time()
     self.delayCallback(self.__getShellDt() - self._desc.shellDt, self._loopOneShoot)
Example #6
0
def freeze(seconds, nextFrame = True):
    if nextFrame:
        LOG_DEBUG('Freeze call at', BigWorld.time())
        BigWorld.callback(0, partial(freeze, seconds, False))
        return
    LOG_DEBUG('Actual Freezing at', BigWorld.time())
    sleep(seconds)
Example #7
0
 def updateDmg(typeTime, typeDmg):
     if (BigWorld.time() - playerData[typeTime]) < 1.0:
         playerData[typeDmg] += _data.data['damage']
     else:
         playerData[typeDmg] = _data.data['damage']
         playerData['n-player'] += 1
     playerData[typeTime] = BigWorld.time()
Example #8
0
 def output(self):
     macroes = None
     if (((data.data['attackReasonID'] in [2, 3]) and config.get(self.section + 'groupDamagesFromRamming_WorldCollision'))
             or ((data.data['attackReasonID'] == 1) and config.get(self.section + 'groupDamagesFromFire'))):
         dataLog = data.data.copy()
         attackerID = data.data['attackerID']
         attackReasonID = data.data['attackReasonID']
         if attackerID in self.dictVehicle:
             if attackReasonID in self.dictVehicle[attackerID]:
                 key = self.dictVehicle[attackerID][attackReasonID]
                 if ('time' in key) and ('damage' in key) and ((BigWorld.serverTime() - key['time']) < 1):
                     key['time'] = BigWorld.serverTime()
                     key['damage'] += data.data['damage']
                     dataLog['damage'] = key['damage']
                     dataLog['dmgRatio'] = dataLog['damage'] * 100 // data.data['maxHealth']
                     if (attackReasonID == 1) and (key['beginFire'] is not None):
                         dataLog['fireDuration'] = BigWorld.time() - key['beginFire']
                     else:
                         dataLog['fireDuration'] = None
             else:
                 self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
                                                                 'damage': data.data['damage'],
                                                                 'beginFire': beginFire if attackReasonID == 1 else None}
                 dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
         else:
             self.dictVehicle[attackerID] = {}
             self.dictVehicle[attackerID][attackReasonID] = {'time': BigWorld.serverTime(),
                                                             'damage': data.data['damage'],
                                                             'beginFire': beginFire if attackReasonID == 1 else None}
             dataLog['fireDuration'] = BigWorld.time() - beginFire if attackReasonID == 1 else None
         macroes = getValueMacroes(self.section, dataLog)
         self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
         if not config.get(self.section + 'moveInBattle'):
             self.x = parser(config.get(self.section + 'x'), macroes)
             self.y = parser(config.get(self.section + 'y'), macroes)
     else:
         if config.get(self.section + 'showHitNoDamage') or data.data['isDamage']:
             macroes = getValueMacroes(self.section, data.data)
             self.strLastHit = parser(config.get(self.section + 'formatLastHit'), macroes)
             if not config.get(self.section + 'moveInBattle'):
                 self.x = parser(config.get(self.section + 'x'), macroes)
                 self.y = parser(config.get(self.section + 'y'), macroes)
         else:
             self.strLastHit = ''
     if self.strLastHit:
         if macroes is None:
             macroes = getValueMacroes(self.section, data.data)
         if (self.timerLastHit is not None) and self.timerLastHit.isStarted:
             self.timerLastHit.stop()
         timeDisplayLastHit = float(parser(config.get(self.section + 'timeDisplayLastHit'), macroes))
         self.timerLastHit = TimeInterval(timeDisplayLastHit, self, 'hideLastHit')
         self.timerLastHit.start()
         self.shadow = shadow_value(self.section, macroes)
         as_event('ON_LAST_HIT')
Example #9
0
 def __cleanupAfterTimeWarp(self):
     BigWorld.wg_clearDecals()
     if self.__replayCtrl.isTimeWarpInProgress:
         self.__timeWarpCleanupTime = BigWorld.time() + 0.5
     self.__timeWarpCleanupCb = None
     if BigWorld.time() < self.__timeWarpCleanupTime:
         self.__timeWarpCleanupCb = BigWorld.callback(0, self.__cleanupAfterTimeWarp)
     else:
         AreaDestructibles.g_destructiblesManager.onAfterReplayRewind()
         AreaDestructibles.g_destructiblesManager.forceNoAnimation = False
         EffectsList.g_disableEffects = False
     return
Example #10
0
 def upGroupFireRamming(pl, typeTime, typeDmg, typeNumberLine, typeNPlayer):
     if (BigWorld.time() - pl[typeTime]) < 1.0:
         isGroup = True
         pl[typeDmg] += _data.data['damage']
     else:
         pl[typeDmg] = _data.data['damage']
         pl['n-player'] += 1
         pl[typeNPlayer] = pl['n-playerShot'] = pl['n-player']
         pl[typeNumberLine] = self.countLines + 1 if self.isAddToEnd else -1
         isGroup = False
     pl[typeTime] = BigWorld.time()
     return isGroup
Example #11
0
 def update(self, manager):
     minimap = self.__minimapRef()
     vehicle = BigWorld.entities.get(self.__vehicleID)
     if vehicle is not None and vehicle.isStarted and not vehicle.isPlayer:
         if self.__nextTime <= BigWorld.time():
             if minimap is not None:
                 minimap.showActionMarker(self.__vehicleID, 'attack')
             self.__nextTime = BigWorld.time() + self.__period
         if self.__dIndicator is not None:
             vPosition = vehicle.position
             vector = vPosition - BigWorld.camera().position
             self.__dIndicator.update(vector.length, vPosition)
Example #12
0
 def update(self, manager):
     feedback = g_sessionProvider.getFeedback()
     vehicle = BigWorld.entities.get(self.__vehicleID)
     if vehicle is not None and vehicle.isStarted and not vehicle.isPlayerVehicle:
         if self.__nextTime <= BigWorld.time():
             if feedback is not None:
                 feedback.showActionMarker(self.__vehicleID, mMarker='attack')
             self.__nextTime = BigWorld.time() + self.__period
         if self.__dIndicator is not None:
             vPosition = vehicle.position
             vector = vPosition - BigWorld.camera().position
             self.__dIndicator.update(vector.length, vPosition)
     return
Example #13
0
 def __init__(self, dataSec, aim, binoculars):
     CallbackDelayer.__init__(self)
     self.__impulseOscillator = None
     self.__movementOscillator = None
     self.__noiseOscillator = None
     self.__dynamicCfg = CameraDynamicConfig()
     self.__accelerationSmoother = None
     self.__readCfg(dataSec)
     if aim is None or binoculars is None:
         return
     else:
         self.__cam = BigWorld.FreeCamera()
         self.__zoom = self.__cfg['zoom']
         self.__curSense = 0
         self.__curScrollSense = 0
         self.__waitVehicleCallbackId = None
         self.__onChangeControlMode = None
         self.__aimingSystem = SniperAimingSystem(dataSec)
         self.__aim = weakref.proxy(aim)
         self.__binoculars = binoculars
         self.__defaultAimOffset = self.__aim.offset()
         self.__defaultAimOffset = (self.__defaultAimOffset[0], self.__defaultAimOffset[1])
         self.__crosshairMatrix = createCrosshairMatrix(offsetFromNearPlane=self.__dynamicCfg['aimMarkerDistance'])
         self.__prevTime = BigWorld.time()
         self.__autoUpdateDxDyDz = Vector3(0, 0, 0)
         return
Example #14
0
    def __init__(self, vehicle):
        self.__vehicle = vehicle
        chassisModel = self.__vehicle.appearance.compoundModel
        topRightCarryingPoint = self.__vehicle.typeDescriptor.chassis['topRightCarryingPoint']
        self.__enabled = True
        self.__trailParticleNodes = []
        self.__trailParticles = {}
        mMidLeft = Math.Matrix()
        mMidLeft.setTranslate((-topRightCarryingPoint[0], 0, 0))
        mMidRight = Math.Matrix()
        mMidRight.setTranslate((topRightCarryingPoint[0], 0, 0))
        self.__trailParticleNodes = [chassisModel.node(TankNodeNames.TRACK_LEFT_MID, mMidLeft), chassisModel.node(TankNodeNames.TRACK_RIGHT_MID, mMidRight)]
        i = 0
        for nodeName in (TankNodeNames.TRACK_LEFT_FRONT,
         TankNodeNames.TRACK_RIGHT_FRONT,
         TankNodeNames.TRACK_LEFT_REAR,
         TankNodeNames.TRACK_RIGHT_REAR):
            identity = Math.Matrix()
            identity.setIdentity()
            node = chassisModel.node(nodeName)
            if node is None:
                raise Exception('Node %s is not found' % nodeName)
            chassisModel.node(nodeName, Math.Matrix(node.localMatrix))
            self.__trailParticleNodes.append(node)

        identity = Math.Matrix()
        identity.setIdentity()
        self.__centerNode = chassisModel.node(TankNodeNames.CHASSIS_MID_TRAIL, identity)
        self.__trailParticlesDelayBeforeShow = BigWorld.time() + 4.0
        return
Example #15
0
    def addControlPoint(self, curveControlPoints, bombing):
        speed = self.__calculateSpeed(curveControlPoints[0], curveControlPoints[1]) if not bombing else self.__fixedSpeed
        point = curveControlPoints[1]
        bombingTime = self.__convertTime(point.time)
        endOfBombingTime = 0.0
        retreatPath = []
        if bombing:
            endOfBombingTime = bombingTime + self.__areaLength / self.__fixedSpeed
            ascendPath = curveControlPoints[1].position - curveControlPoints[0].position
            ascendPath.y = -ascendPath.y
            descendTime = curveControlPoints[1].time - curveControlPoints[0].time
            retreatPath.append((ascendPath, endOfBombingTime + descendTime))
        bomberSpeed = speed * point.direction
        for bomber, offset in zip(self.__bombers, self.__offsets):
            realOffset = self.__calculateOffset(offset, self.__calculateDirAndNorm(point.direction))
            bomberPosition = point.position + realOffset
            bomber.addControlPoint(bomberPosition, bomberSpeed, bombingTime)
            if bombing:
                bomber.startAttack(True)
                bomberPosition += point.direction * self.__areaLength
                bomber.addControlPoint(bomberPosition, bomberSpeed, endOfBombingTime, True)
                retreatPath = self.__generateRetreatTrajectory(curveControlPoints[0].position.y, bomberPosition, point.direction, endOfBombingTime)
                for bomberRetreatPosition, retreatVelocity, bomberTime in retreatPath:
                    bomber.addControlPoint(bomberRetreatPosition, retreatVelocity, bomberTime, True)

                self.delayCallback(retreatPath[-1].time - BigWorld.time(), self.__onFlightComplete)
Example #16
0
 def navigateStop(self):
     if BigWorld.time() - self.__loadStartTime < 0.5:
         LOG_BROWSER('navigateStop - called too soon')
         return
     if self.hasBrowser:
         self.__browser.stop()
         self.__onLoadEnd()
Example #17
0
    def __onResourcesLoaded(self, resourceRefs):
        if self.guid not in BigWorld.userDataObjects:
            return
        else:
            self.__clear()
            if self.modelName in resourceRefs.failedIDs:
                return
            try:
                self.__model = resourceRefs[self.modelName]
                self.__modelMatrix = Matrix()
                self.__modelMatrix.setIdentity()
                servo = BigWorld.Servo(self.__modelMatrix)
                self.__model.addMotor(servo)
                BigWorld.addModel(self.__model)
                if self.actionName != '':
                    action = self.__model.action(self.actionName)
                    if action is not None:
                        action()
                if self.pixieName != '' and self.pixieName not in resourceRefs.failedIDs:
                    pixieNode = self.__model.node(self.pixieHardPoint)
                    pixieNode.attach(resourceRefs[self.pixieName])
                if self.soundName != '':
                    self.__sound = SoundGroups.g_instance.playSoundModel(self.__model, self.soundName)
            except:
                LOG_CURRENT_EXCEPTION()
                self.__model = None
                return

            self.__prevTime = BigWorld.time()
            self.__update()
            return
Example #18
0
 def __cameraUpdate(self, allowModeChange = True):
     curTime = BigWorld.time()
     deltaTime = curTime - self.__prevTime
     self.__prevTime = curTime
     if not self.__autoUpdateDxDyDz.x == self.__autoUpdateDxDyDz.y == self.__autoUpdateDxDyDz.z == 0.0:
         self.__rotateAndZoom(self.__autoUpdateDxDyDz.x, self.__autoUpdateDxDyDz.y, self.__autoUpdateDxDyDz.z)
     self.__aimingSystem.update(deltaTime)
     localTransform, impulseTransform = self.__updateOscillators(deltaTime)
     aimMatrix = cameras.getAimMatrix(*self.__defaultAimOffset)
     camMat = Matrix(aimMatrix)
     rodMat = mathUtils.createTranslationMatrix(-self.__dynamicCfg['pivotShift'])
     antiRodMat = mathUtils.createTranslationMatrix(self.__dynamicCfg['pivotShift'])
     camMat.postMultiply(rodMat)
     camMat.postMultiply(localTransform)
     camMat.postMultiply(antiRodMat)
     camMat.postMultiply(self.__aimingSystem.matrix)
     camMat.invert()
     self.__cam.set(camMat)
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
         aimOffset = replayCtrl.getAimClipPosition()
         binocularsOffset = aimOffset
     else:
         aimOffset = self.__calcAimOffset(impulseTransform)
         binocularsOffset = self.__calcAimOffset()
         if replayCtrl.isRecording:
             replayCtrl.setAimClipPosition(aimOffset)
     self.__aim.offset(aimOffset)
     self.__binoculars.setMaskCenter(binocularsOffset.x, binocularsOffset.y)
     player = BigWorld.player()
     if allowModeChange and (self.__isPositionUnderwater(self.__aimingSystem.matrix.translation) or player.isGunLocked):
         self.__onChangeControlMode(False)
         return -1
     return 0.0
Example #19
0
def isRequestInCoolDown(scopeID, rqTypeID):
    global _g_coolDowns
    result = False
    uniqueID = (scopeID, rqTypeID)
    if uniqueID in _g_coolDowns:
        result = _g_coolDowns[uniqueID] > BigWorld.time()
    return result
    def onProjectileExploded(self, hitParams, damagedDestructibles):
        self.__reduceExplosionCacheByTimeout()
        explosionInfo = [hitParams, True]
        explDestrs = self.__explodedDestructibles
        gotDestrs = False
        restDamagedDestructibles = []
        for chunkID, itemIndex, matKind in damagedDestructibles:
            found = False
            for destr in explDestrs:
                time, itemInfo = destr
                chunkID_, itemIndex_, matKind_, dmgType, destrData = itemInfo
                if chunkID_ == chunkID and itemIndex_ == itemIndex and (dmgType == DESTR_TYPE_FRAGILE or matKind_ == matKind):
                    self.__destroyDestructible(chunkID, dmgType, destrData, True, explosionInfo)
                    explDestrs.remove(destr)
                    found = True
                    gotDestrs = True
                    break

            if not found:
                restDamagedDestructibles.append((chunkID, itemIndex, matKind))

        if restDamagedDestructibles:
            newExpl = (BigWorld.time(), explosionInfo, restDamagedDestructibles)
            self.__projectileExplosions.append(newExpl)
        if not gotDestrs:
            BigWorld.callback(_SHOT_EXPLOSION_SYNC_TIMEOUT + DESTRUCTIBLE_HIDING_DELAY, partial(self.__delayedHavokExplosion, self.__spaceID, explosionInfo))
 def __init__(self):
     self.items = {}
     self.damaged = []
     self.destroyed = []
     self.fired = False
     self.ConsumablesPanel = None
     self.config = config.data.get('config')
     self.int_cd = {'extinguisher': 251, 'med_kit': 763, 'repair_kit': 1275, 'g_repair_kit': 1531, 'g_med_kit': 1019}
     self.crew = ['_None', 'commander', 'radioman', 'driver', 'driver1', 'driver2', 'gunner', 'gunner1', 'gunner2', 'loader', 'loader1', 'loader2']
     self.device = ['_None', 'gun', 'engine', 'ammoBay', 'turretRotator', 'chassis', 'leftTrack', 'rightTrack', 'surveyingDevice', 'radio', 'fuelTank']
     self.v_FireCodes = ('FIRE', 'DEVICE_STARTED_FIRE_AT_SHOT', 'DEVICE_STARTED_FIRE_AT_RAMMING', 'FIRE_STOPPED')
     self.v_DamageCodes = (
         'DEVICE_CRITICAL', 'DEVICE_REPAIRED_TO_CRITICAL', 'DEVICE_CRITICAL_AT_SHOT', 'DEVICE_CRITICAL_AT_RAMMING', 'DEVICE_CRITICAL_AT_FIRE', 'DEVICE_CRITICAL_AT_WORLD_COLLISION',
         'DEVICE_CRITICAL_AT_DROWNING', 'ENGINE_CRITICAL_AT_UNLIMITED_RPM', 'DEVICE_DESTROYED', 'DEVICE_DESTROYED_AT_SHOT', 'DEVICE_DESTROYED_AT_RAMMING', 'DEVICE_DESTROYED_AT_FIRE',
         'DEVICE_DESTROYED_AT_WORLD_COLLISION', 'DEVICE_DESTROYED_AT_DROWNING', 'ENGINE_DESTROYED_AT_UNLIMITED_RPM')
     self.v_RepairedCodes = ('DEVICE_REPAIRED_TO_CRITICAL',)
     self.v_Destroyed_Codes = (
         'DEVICE_DESTROYED', 'DEVICE_DESTROYED_AT_SHOT', 'DEVICE_DESTROYED_AT_RAMMING', 'DEVICE_DESTROYED_AT_FIRE', 'DEVICE_DESTROYED_AT_WORLD_COLLISION', 'DEVICE_DESTROYED_AT_DROWNING',
         'ENGINE_DESTROYED_AT_UNLIMITED_RPM')
     self.m_DamageCodes = (
         'TANKMAN_HIT_AT_RAMMING', 'TANKMAN_HIT_AT_FIRE', 'TANKMAN_HIT_AT_EXPLOSION', 'TANKMAN_HIT', 'TANKMAN_HIT_AT_SHOT', 'TANKMAN_HIT_AT_WORLD_COLLISION', 'TANKMAN_HIT_AT_DROWNING',
         'TANKMAN_HIT_AT_DROWNING')
     self.DeathCodes = (
         'DEATH_FROM_DEVICE_EXPLOSION_AT_FIRE', 'DEATH_FROM_DEVICE_EXPLOSION_AT_SHOT', 'DEATH_FROM_FIRE', 'DEATH_FROM_INACTIVE_CREW', 'DEATH_FROM_INACTIVE_CREW_AT_SHOT', 'DEATH_FROM_RAMMING',
         'DEATH_FROM_SHOT')
     self.time = BigWorld.time()
Example #22
0
    def __init__(self, vehicle):
        self.__vehicle = vehicle
        chassisModel = self.__vehicle.appearance.modelsDesc['chassis']['model']
        topRightCarryingPoint = self.__vehicle.typeDescriptor.chassis['topRightCarryingPoint']
        self.__enabled = True
        self.__trailParticleNodes = []
        self.__trailParticles = {}
        mMidLeft = Math.Matrix()
        mMidLeft.setTranslate((-topRightCarryingPoint[0], 0, 0))
        mMidRight = Math.Matrix()
        mMidRight.setTranslate((topRightCarryingPoint[0], 0, 0))
        self.__trailParticleNodes = [chassisModel.node('', mMidLeft), chassisModel.node('', mMidRight)]
        i = 0
        for nodeName in ('HP_Track_LFront', 'HP_Track_RFront', 'HP_Track_LRear', 'HP_Track_RRear'):
            try:
                identity = Math.Matrix()
                identity.setIdentity()
                node = chassisModel.node(nodeName, identity)
            except:
                matr = mMidLeft if i % 2 == 0 else mMidRight
                node = chassisModel.node('', Math.Matrix(matr))

            self.__trailParticleNodes.append(node)

        identity = Math.Matrix()
        identity.setIdentity()
        self.__centerNode = chassisModel.node('', identity)
        self.__trailParticlesDelayBeforeShow = BigWorld.time() + 4.0
 def addItem(self, clientID, data):
     label = data["label"]
     tooltipData = data.get("tooltipData", None)
     if tooltipData is None:
         tooltipData = TOOLTIP_PRB_DATA(tooltipId=None, label=label)._asdict()
     item = {
         "clientID": clientID,
         "label": label,
         "canClose": data.get("canClose", False),
         "isNotified": data.get("isNotified", False),
         "icon": data.get("icon"),
         "order": data.get("order", (0, BigWorld.time())),
         "isInProgress": data.get("isInProgress", False),
         "isWindowOpened": data.get("isWindowOpened", False),
         "readyData": data.get("readyData", None),
         "isWindowFocused": data.get("isWindowFocused", False),
         "tooltipData": tooltipData,
     }
     if clientID in self.__data:
         self.__data[clientID].update(item)
     else:
         self.__data[clientID] = item
     self.buildList()
     self.refresh()
     return
 def __update(self):
     if self.__manualSound is None:
         return
     elif not hasattr(BigWorld.player(), 'gunRotator'):
         return
     else:
         p = BigWorld.player().gunRotator
         if p.maxturretRotationSpeed is not None and p.maxturretRotationSpeed > 0:
             self.__manualSound.setRTPC('RTPC_ext_turret_speed', p.turretRotationSpeed / p.maxturretRotationSpeed)
         else:
             self.__manualSound.setRTPC('RTPC_ext_turret_speed', 0)
         player = BigWorld.player()
         vehicleTypeDescriptor = player.vehicleTypeDescriptor
         gunRotator = player.gunRotator
         turretYaw = gunRotator.turretYaw
         desiredShotPoint = gunRotator.predictLockedTargetShotPoint()
         if desiredShotPoint is None:
             desiredShotPoint = player.inputHandler.getDesiredShotPoint()
         if desiredShotPoint is None:
             desiredShotPoint = gunRotator.markerInfo[0]
         cameraTurretYaw, _ = AimingSystems.getTurretYawGunPitch(vehicleTypeDescriptor, player.getOwnVehicleStabilisedMatrix(), desiredShotPoint, True)
         angleDiff = abs(turretYaw - cameraTurretYaw)
         if angleDiff > math.pi:
             angleDiff = 2 * math.pi - angleDiff
         self.__manualSound.setRTPC('RTPC_ext_turret_angle', angleDiff)
         turretPitch = BigWorld.player().gunRotator.gunPitch
         self.__manualSound.setRTPC('RTPC_ext_turret_pitch', turretPitch)
         self.__manualSound.setRTPC('RTPC_ext_turret_pitch_speed', abs(self.__oldPitch - turretPitch) / (BigWorld.time() - self.__oldTime))
         self.__oldPitch = turretPitch
         self.__oldTime = BigWorld.time()
         self.__manualSound.setRTPC('RTPC_ext_turret_damaged', 0 if BigWorld.player().deviceStates.get('turretRotator', None) is None else 1)
         return self.__updatePeriod
Example #25
0
    def __updateNodeEffect(self, nodeEffect, node, nodeEffects, relSpeed, stopParticles):
        relEmissionRate = 0.0 if stopParticles else abs(relSpeed)
        basicEmissionRates = nodeEffect[4]
        pixie = nodeEffect[0]
        if pixie is None:
            return
        else:
            for i in xrange(pixie.nSystems()):
                if basicEmissionRates[i] < 0:
                    source = pixie.system(i).action(16)
                    source.MultRate(relEmissionRate)
                else:
                    source = pixie.system(i).action(1)
                    source.rate = relEmissionRate * basicEmissionRates[i]

            effectInactive = relEmissionRate < 0.0001
            if effectInactive:
                time = BigWorld.time()
                timeOfStop = nodeEffect[3]
                if timeOfStop == 0:
                    nodeEffect[3] = time
                elif time - timeOfStop > 5.0 or material_kinds.EFFECT_MATERIALS[nodeEffect[1]] == 'water':
                    pixie = nodeEffect[0]
                    node.detach(pixie)
                    nodeEffects.remove(nodeEffect)
            else:
                nodeEffect[3] = 0
            return
Example #26
0
 def __init__(self, vehicleID, minimap, period, dIndicator = None):
     super(_VehicleMarker, self).__init__()
     self.__vehicleID = vehicleID
     self.__minimapRef = weakref.ref(minimap)
     self.__period = period
     self.__nextTime = BigWorld.time()
     self.__dIndicator = dIndicator
 def __checkAcceleration(self, vehicle):
     totalAccelerationTime = (
         0 if self.__accelerationStartTime is None else time.time() - self.__accelerationStartTime
     )
     ACC_ENGINE_MODE = 3
     if vehicle.engineMode[0] == ACC_ENGINE_MODE and self.__prevEnginePower != ACC_ENGINE_MODE:
         VibroManager.g_instance.startEffect(self.__accelerationEffect)
         self.__accelerationStartTime = time.time()
     elif (
         vehicle.engineMode[0] != ACC_ENGINE_MODE
         and self.__prevEnginePower == ACC_ENGINE_MODE
         or totalAccelerationTime > self.__accelerationEffect.getDuration()
     ):
         if self.__accelerationEffect.isRunning():
             VibroManager.g_instance.stopEffect(self.__accelerationEffect)
         if vehicle.engineMode[0] != ACC_ENGINE_MODE:
             self.__accelerationStartTime = None
     curSpeed = vehicle.getSpeed()
     curTime = BigWorld.time()
     deltaT = curTime - self.__lastTime
     acc = (curSpeed - self.__lastVehicleSpeed) / deltaT
     if acc <= EffectsSettings.DecelerationThreshold:
         VibroManager.g_instance.startEffect(self.__brakingEffect)
     else:
         VibroManager.g_instance.stopEffect(self.__brakingEffect)
     self.__lastVehicleSpeed = curSpeed
     self.__lastTime = curTime
     self.__prevEnginePower = vehicle.engineMode[0]
     return
 def __onTick(self):
     self.__timerID = BigWorld.callback(self.__ROTATION_TICK_LENGTH, self.__onTick)
     lockEnabled = BigWorld.player().inputHandler.getAimingMode(AIMING_MODE.TARGET_LOCK)
     usePredictedLockShotPoint = lockEnabled and VehicleGunRotator.USE_LOCK_PREDICTION
     replayCtrl = BattleReplay.g_replayCtrl
     if not self.__clientMode and not replayCtrl.isPlaying and not usePredictedLockShotPoint:
         return
     else:
         replayCtrl = BattleReplay.g_replayCtrl
         if replayCtrl.isPlaying:
             shotPoint = replayCtrl.getGunRotatorTargetPoint()
         else:
             predictedLockShotPoint = self.predictLockedTargetShotPoint() if usePredictedLockShotPoint else None
             shotPoint = self.__shotPointSourceFunctor() if predictedLockShotPoint is None else predictedLockShotPoint
         if shotPoint is None and self.__targetLastShotPoint:
             shotPoint = self.__lastShotPoint
         if replayCtrl.isRecording:
             if shotPoint is not None:
                 replayCtrl.setGunRotatorTargetPoint(shotPoint)
         self.__updateShotPointOnServer(shotPoint)
         timeDiff = self.__getTimeDiff()
         if timeDiff is None:
             return
         self.__time = BigWorld.time()
         self.__rotate(shotPoint, timeDiff)
         self.__updateGunMarker()
         if replayCtrl.isPlaying:
             replayCtrl.resetUpdateGunOnTimeWarp()
         return
    def __playFirstFromQueue(self, category):
        if not self.__isEnabled:
            return
        else:
            queue = self.__soundQueues[category]
            time = BigWorld.time()
            while len(queue) > 0:
                soundPath, timeout, minTimeBetweenEvents, vehicleIdToBind, checkFn, sndPos = queue[0]
                del queue[0]
                if vehicleIdToBind is not None:
                    vehicles = BigWorld.player().arena.vehicles
                    vehicleInfo = vehicles.get(vehicleIdToBind)
                    if vehicleInfo is None or not vehicleInfo['isAlive']:
                        continue
                if checkFn is not None and not checkFn():
                    continue
                if time > timeout:
                    continue
                if sndPos is not None:
                    sound = SoundGroups.g_instance.getCameraOriented(soundPath, sndPos)
                else:
                    sound = SoundGroups.g_instance.getSound2D(soundPath)
                if sound is not None:
                    sound.setCallback(partial(self.__onSoundEnd, category))
                    sound.play()
                    self.__activeEvents[category] = {'sound': sound,
                     'soundPath': soundPath}
                return

            return
Example #30
0
 def refresh(self, ignoreCache = True):
     if BigWorld.time() - self.__loadStartTime < 0.5:
         LOG_BROWSER('refresh - called too soon')
         return
     if self.hasBrowser:
         self.__browser.reload(ignoreCache)
         self.onNavigate(self.__browser.url)
Example #31
0
 def __onLoadStart(self, url):
     if url == self.__browser.url:
         self.__isNavigationComplete = False
         self.__loadStartTime = BigWorld.time()
         _logger.debug('onLoadStart %s', self.__browser.url)
         self.onLoadStart(self.__browser.url)
         self.__readyToShow = False
         self.__successfulLoad = False
 def start(self, shellReloadTime, ammoLow, directTrigger=False):
     if gEffectsDisabled() or not directTrigger:
         return
     else:
         SoundGroups.g_instance.setSwitch(_CALIBER_RELOAD_SOUND_SWITCH, self._desc.caliber)
         self.stopCallback(self.__onReloadStart)
         timeToStart = shellReloadTime - self._desc.runTimeDelta
         if self.__sound is None:
             self.__sound = SoundGroups.g_instance.getSound2D(self._desc.soundEvent)
         if timeToStart > 0:
             self.delayCallback(timeToStart, self.__onReloadStart, BigWorld.time() + timeToStart)
         if ammoLow:
             timeToStart = shellReloadTime - self._desc.runTimeDeltaAmmoLow
             self.__ammoLowSound = SoundGroups.g_instance.getSound2D(self._desc.ammoLowSound)
             self.delayCallback(timeToStart, self.__onAmmoLow, BigWorld.time() + timeToStart)
         self._checkAndPlayGunRammerEffect(shellReloadTime)
         return
Example #33
0
 def wheelsScrollSmoothed(self):
     if self.__wheelsScrollFilter is not None:
         return [
             scrollFilter.output(BigWorld.time())
             for scrollFilter in self.__wheelsScrollFilter
         ]
     else:
         return
Example #34
0
 def wheelsSteeringSmoothed(self):
     if self.__wheelsSteeringFilter is not None:
         return [
             steeringFilter.output(BigWorld.time())
             for steeringFilter in self.__wheelsSteeringFilter
         ]
     else:
         return
Example #35
0
def genOrder4Channel(channel):
    primary = PRIMARY_CHANNEL_ORDER.OTHER
    secondary = BigWorld.time()
    if channel.getName() in LAZY_CHANNEL.ALL:
        primary = PRIMARY_CHANNEL_ORDER.LAZY
    elif channel.isSystem():
        primary = PRIMARY_CHANNEL_ORDER.SYSTEM
    return (primary, secondary)
 def setSpotted(self, vehicleID):
     vehicle = BigWorld.entities.get(vehicleID, None)
     if vehicle is not None:
         SoundGroups.g_instance.playCameraOriented(
             'cons_radio_sighted_for_team', Math.Vector3(vehicle.position))
     else:
         self.__spottedVehicles[vehicleID] = BigWorld.time()
     return
Example #37
0
 def __getTimeDiff(self):
     timeDiff = BigWorld.time() - self.__time
     if timeDiff < self.__INSUFFICIENT_TIME_DIFF:
         return None
     else:
         if timeDiff > self.__MAX_TIME_DIFF:
             timeDiff = self.__MAX_TIME_DIFF
         return timeDiff
Example #38
0
 def addMarker(cls, markerID, marker, config):
     if len(cls.__markers) == config["maxArrows"]:
         MarkersStorage.removeOldest()
     cls.__markers.append({
         "time": BigWorld.time(),
         "marker": marker,
         "id": markerID
     })
Example #39
0
    def set_steeringAngles(self, prev=None):
        if self.__wheelsSteeringFilter is not None:
            for packedValue, steeringFilter in zip(
                    self.steeringAngles, self.__wheelsSteeringFilter):
                unpackedValue = WoT.unpackWheelSteering(packedValue)
                steeringFilter.input(BigWorld.time(), unpackedValue)

        return
 def startVehicleVisual(self, vProxy, isImmediate):
     if isImmediate and vProxy.id in self.__spottedVehicles:
         if abs(BigWorld.time() -
                self.__spottedVehicles[vProxy.id]) < self._TIME_DELTA:
             SoundGroups.g_instance.playCameraOriented(
                 'cons_radio_sighted_for_team',
                 Math.Vector3(vProxy.position))
         del self.__spottedVehicles[vProxy.id]
 def __addRequest(self, timeoutSec, callback):
     reqID = self.__nextReqID
     if reqID < 2147483647L:
         self.__nextReqID = reqID + 1
     else:
         self.__nextReqID = 1
     self.__reqs[reqID] = (BigWorld.time() + timeoutSec, callback)
     return reqID
Example #42
0
    def set_wheelsScroll(self, prev=None):
        if self.__wheelsScrollFilter is not None:
            for packedValue, scrollFilter in zip(self.wheelsScroll,
                                                 self.__wheelsScrollFilter):
                unpackedValue = WoT.unpackWheelScroll(packedValue)
                scrollFilter.input(BigWorld.time(), unpackedValue)

        return
Example #43
0
def as_setFireInVehicleS(self, isInFire):
    global on_fire, beginFire
    if isInFire:
        on_fire = 100
        beginFire = BigWorld.time()
    else:
        on_fire = 0
    as_event('ON_FIRE')
 def __cameraUpdate(self):
     replayCtrl = BattleReplay.g_replayCtrl
     if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
         aimOffset = replayCtrl.getAimClipPosition()
     else:
         aimOffset = self.__calcAimOffset()
         if replayCtrl.isRecording:
             replayCtrl.setAimClipPosition(aimOffset)
     self.__aimOffset = aimOffset
     shotDescr = BigWorld.player().getVehicleDescriptor().shot
     BigWorld.wg_trajectory_drawer().setParams(
         shotDescr.maxDistance, Math.Vector3(0, -shotDescr.gravity, 0),
         aimOffset)
     curTime = BigWorld.time()
     deltaTime = curTime - self.__prevTime
     self.__prevTime = curTime
     self.__aimingSystem.update(deltaTime)
     if replayCtrl.isPlaying:
         if self.__needReset != 0:
             if self.__needReset > 1:
                 from helpers import isPlayerAvatar
                 player = BigWorld.player()
                 if isPlayerAvatar():
                     if player.inputHandler.ctrl is not None:
                         player.inputHandler.ctrl.resetGunMarkers()
                 self.__needReset = 0
             else:
                 self.__needReset += 1
         if replayCtrl.isControllingCamera:
             self.__aimingSystem.updateTargetPos(
                 replayCtrl.getGunRotatorTargetPoint())
         else:
             self.__aimingSystem.handleMovement(
                 self.__dxdydz.x * self.__curSense,
                 -self.__dxdydz.y * self.__curSense)
             if self.__dxdydz.x != 0 or self.__dxdydz.y != 0 or self.__dxdydz.z != 0:
                 self.__needReset = 2
     else:
         self.__aimingSystem.handleMovement(
             self.__dxdydz.x * self.__curSense,
             -self.__dxdydz.y * self.__curSense)
     distRange = self.__getDistRange()
     self.__calcSmoothingPivotDelta(deltaTime)
     self.__camDist -= self.__dxdydz.z * float(self.__curSense)
     self.__camDist = self.__aimingSystem.overrideCamDist(self.__camDist)
     distRange = self.__getDistRange()
     maxPivotHeight = distRange[1] - distRange[0]
     self.__camDist = mathUtils.clamp(0, maxPivotHeight, self.__camDist)
     self.__cfg['camDist'] = self.__camDist
     camDistWithSmoothing = self.__camDist + self.__smoothingPivotDelta - self.__aimingSystem.heightFromPlane
     self.__cam.pivotPosition = Math.Vector3(0.0, camDistWithSmoothing, 0.0)
     if self.__dxdydz.z != 0 and self.__onChangeControlMode is not None and mathUtils.almostZero(
             self.__camDist - maxPivotHeight):
         self.__onChangeControlMode()
     self.__updateOscillator(deltaTime)
     if not self.__autoUpdatePosition:
         self.__dxdydz = Vector3(0, 0, 0)
     return 0.0
Example #45
0
 def __update(self, arenaLevel, animationState):
     if BigWorld.time(
     ) - self.__lastXPUpdateTime < self.__XP_UPDATE_TIME_DIFF:
         animationState = False
     self.__lastXPUpdateTime = BigWorld.time()
     if not self.__isInitialized:
         self.as_setAnimationS(False)
         self.__isInitialized = True
     else:
         self.as_setAnimationS(animationState)
         if not animationState and not arenaLevel.isMaxLvlAchieved:
             expText = '{currentXP} / {targetXP}'.format(
                 currentXP=arenaLevel.xp, targetXP=arenaLevel.targetXP)
             self.as_setLevelS(int2roman(arenaLevel.level),
                               int2roman(arenaLevel.level + 1), expText)
     if arenaLevel.xp == 0 and arenaLevel.level == 1:
         expText = ' / {targetXP}'.format(targetXP=arenaLevel.targetXP)
         self.as_setLevelS(int2roman(arenaLevel.level),
                           int2roman(arenaLevel.level + 1), expText)
         self.as_setExperienceS(0, expText, 0, 0, False)
         return
     if arenaLevel.levelIsChanged:
         expText = ' / {targetXP}'.format(targetXP=arenaLevel.baseXP)
         percent = IProgressionListener.MAX_PERCENT_AMOUNT
         xp = arenaLevel.baseXP
     else:
         expText = ' / {targetXP}'.format(targetXP=arenaLevel.targetXP)
         percent = arenaLevel.percent
         xp = arenaLevel.xp
     playSound = arenaLevel.diff >= self.__SOUND_XP_DIFF and not self.__firstShow
     self.as_setExperienceS(xp, expText, arenaLevel.diff, percent,
                            playSound)
     if arenaLevel.isMaxLvlAchieved:
         self.as_setMaxLevelReachedS(int2roman(arenaLevel.level))
         self.__maxLevelAchieved = True
         return
     if arenaLevel.levelIsChanged or self.__firstShow:
         expText = '{baseXP} / {targetXP}'.format(
             baseXP=arenaLevel.baseXP, targetXP=arenaLevel.targetXP)
         self.as_setLevelS(int2roman(arenaLevel.level),
                           int2roman(arenaLevel.level + 1), expText)
         expText = ' / {targetXP}'.format(targetXP=arenaLevel.targetXP)
         self.as_setExperienceS(arenaLevel.xp, expText,
                                arenaLevel.diffAfterLevel,
                                arenaLevel.percent, playSound)
Example #46
0
 def getTimeLeftInSearch(self):
     """
     Get time that left in search
     """
     if self.__startSearchTime > -1:
         timeLeft = int(BigWorld.time() - self.__startSearchTime)
     else:
         timeLeft = -1
     return timeLeft
 def _start(self, data, args):
     data['_isStarted'] = False
     vehicle = data['entity']
     isUnderwater = vehicle.appearance.isUnderwater
     if not isUnderwater:
         self.__playEffect(data)
     data['_isStarted'] = True
     data['_invokeTime'] = BigWorld.time()
     vehicle.appearance.switchFireVibrations(True)
Example #48
0
 def __encodeEvent(self, subSystemType, eventType, uiid, arg):
     eventTypeIdx = EVENT_LOG_CONSTANTS.EVENT_TYPES.index(eventType)
     eventTypeId = EVENT_LOG_CONSTANTS.EVENT_CODES[eventTypeIdx]
     timestamp = int(BigWorld.time())
     return [timestamp,
      subSystemType,
      eventTypeId,
      uiid,
      arg]
 def __launchPlane(self):
     if self.parent is not None:
         self.plane = DropPlane(self.deliveryPosition, self.DROP_ALTITUDE,
                                self.deliveryTime - self.DESCEND_TIME)
         self.parent.addComponent(self.plane)
     self.delayCallback(
         self.deliveryTime + self.FLY_TIME_AFTER_DROP - BigWorld.time(),
         self.__processFlightEnd)
     return
Example #50
0
 def __init__(self, position, distance, idM, time=None):
     self.idM = idM
     if time is None:
         self.time = BigWorld.time()
     else:
         self.time = time
     self.position = position
     self.distance = distance
     self.handle = None
Example #51
0
 def __isCooldownInProcess(self, actionID, args=None):
     command = _ACTIONS.battleChatCommandFromActionID(actionID)
     if command:
         currTime = BigWorld.time()
         targetID = args['int32Arg1']
         sndrBlockReason = areSenderCooldownsActive(currTime, self.__battleCmdCooldowns, actionID, targetID)
         return command.name not in CHAT_COMMANDS_THAT_IGNORE_COOLDOWNS and sndrBlockReason is not None
     else:
         return self.__coolDown.isInProcess(actionID)
Example #52
0
 def __init__(self, notID, ttl, actions, items):
     super(_NotificationVO, self).__init__()
     self.notID = notID
     self.ttl = ttl
     self.actions = actions
     self.items = items
     self.order = BigWorld.time()
     self.marked = False
     self.client = None
Example #53
0
 def __shouldShowErrorMessage(self, actionID, args=None):
     command = _ACTIONS.battleChatCommandFromActionID(actionID)
     if command is None:
         return False
     else:
         currTime = BigWorld.time()
         targetID = args['int32Arg1']
         sndrBlockReason = areSenderCooldownsActive(currTime, self.__battleCmdCooldowns, actionID, targetID)
         return sndrBlockReason.cooldownType != CHAT_COMMAND_COOLDOWN_TYPE_IDS.TIMEFRAME_DATA_COOLDOWN if sndrBlockReason is not None else False
Example #54
0
 def getAvatarOwnVehicleStabilisedMatrix(self):
     avatar = self.__avatar
     vehicleMatrix = Math.Matrix(avatar.getOwnVehicleStabilisedMatrix())
     if self.__getTurretStaticYaw(
     ) is not None and avatar.vehicle is not None:
         vehicleMatrix = Math.Matrix(
             avatar.vehicle.filter.interpolateStabilisedMatrix(
                 BigWorld.time()))
     return vehicleMatrix
Example #55
0
 def __filterMessage(self, text, userUid):
     owner = BigWorld.player()
     if owner and owner.id != userUid:
         if Settings.g_instance.getXmppChatSettings(
         )['messageFilterEnabled']:
             result = self._filterChain.chainIn(convertToLocal(text),
                                                userUid, BigWorld.time())
             return utf_8.encode(result)[0]
     return text
Example #56
0
 def pe_onEnqueuedUnitAssembler(self):
     self.__isInSearch = True
     self.__startSearchTime = BigWorld.time()
     g_eventDispatcher.setUnitProgressInCarousel(
         self.__functional.getEntityType(), True)
     for listener in self.__functional.getListenersIterator():
         listener.onUnitAutoSearchStarted(0)
     else:
         g_eventDispatcher.showUnitWindow(self.__functional.getEntityType())
 def onClipLoad(self, timeLeft, shellCount, lastShell, canBeFull):
     if BARREL_DEBUG_ENABLED:
         LOG_DEBUG('AutoReload::onClipLoad time = {0} {1} {2} {3}'.format(
             BigWorld.time(), timeLeft, shellCount, lastShell))
     self.stopCallback(self.__onAlmostComplete)
     self.stopCallback(self.__onClipShellLoad)
     if shellCount > 0 and not lastShell:
         time = timeLeft - self._desc.clipShellLoadT
         if time < 0.0:
             time = 0.0
         self.delayCallback(time, self.__onClipShellLoad,
                            BigWorld.time() + time)
     if lastShell and canBeFull:
         time = timeLeft - self._desc.almostCompleteT
         if time < 0.0:
             time = 0.0
         self.delayCallback(time, self.__onAlmostComplete,
                            BigWorld.time() + time)
Example #58
0
class TokenResponse(object):
    __slots__ = ('_receivedAt', '_token', '_databaseID', '_error')

    def __init__(self, token = None, databaseID = 0L, error = None, **kwargs):
        super(TokenResponse, self).__init__()
        self._receivedAt = BigWorld.time()
        self._token = token
        self._databaseID = databaseID
        self._error = error
Example #59
0
 def navigateStop(self):
     if self.__loadStartTime is None or BigWorld.time(
     ) - self.__loadStartTime < 0.5:
         _logger.debug('navigateStop - called too soon')
         return
     else:
         if self.hasBrowser:
             self.__browser.stop()
             self.__onLoadEnd(self.__browser.url)
         return
Example #60
0
 def __init__(self, condition, timeout=None, checkFrequency=0.01):
     _BWWaitObject.__init__(self)
     self._condition = condition
     self._checkFrequency = checkFrequency
     if timeout is not None:
         self._timeoutTime = BigWorld.time() + timeout
     else:
         self._timeoutTime = None
     self._stopped = False
     return