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
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)
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))
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))
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)
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)
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()
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')
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
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
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)
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
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
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
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)
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()
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
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
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()
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
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
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
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)
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
def wheelsScrollSmoothed(self): if self.__wheelsScrollFilter is not None: return [ scrollFilter.output(BigWorld.time()) for scrollFilter in self.__wheelsScrollFilter ] else: return
def wheelsSteeringSmoothed(self): if self.__wheelsSteeringFilter is not None: return [ steeringFilter.output(BigWorld.time()) for steeringFilter in self.__wheelsSteeringFilter ] else: return
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
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
def addMarker(cls, markerID, marker, config): if len(cls.__markers) == config["maxArrows"]: MarkersStorage.removeOldest() cls.__markers.append({ "time": BigWorld.time(), "marker": marker, "id": markerID })
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
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
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
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)
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)
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
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
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)
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
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
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
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
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)
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
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
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