Python CallbackDelayer.__init__方法代码示例

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, configDataSec):
     CallbackDelayer.__init__(self)
     TimeDeltaMeter.__init__(self, time.clock)
     self.__cam = BigWorld.FreeCamera()
     self.__cam.invViewProvider = Math.MatrixProduct()
     self.__ypr = Math.Vector3()
     self.__position = Math.Vector3()
     self.__defaultFov = BigWorld.projection().fov
     self.__velocity = Math.Vector3()
     self.__isVerticalVelocitySeparated = False
     self.__yprVelocity = Math.Vector3()
     self.__zoomVelocity = 0.0
     self.__inertiaEnabled = False
     self.__movementInertia = None
     self.__rotationInertia = None
     self.__movementSensor = None
     self.__verticalMovementSensor = None
     self.__rotationSensor = None
     self.__zoomSensor = None
     self.__targetRadiusSensor = None
     self.__mouseSensitivity = 0.0
     self.__scrollSensitivity = 0.0
     self.__rotateAroundPointEnabled = False
     self.__rotationRadius = 40.0
     self.__alignerToLand = _AlignerToLand()
     self.__predefinedVelocities = {}
     self.__predefinedVerticalVelocities = {}
     self.__keySwitches = {}
     self.__readCfg(configDataSec)
     self.__aim = None
     self.__basisMProv = _VehicleBounder()
     self.__entityPicker = _VehiclePicker()
     return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, updatePeriod = 0.0):
     CallbackDelayer.__init__(self)
     self.__updatePeriod = updatePeriod
     self.__currentSpeedState = self.__SPEED_IDLE
     self.__keyOffCalled = False
     self.__manualSound = None
     self.__gearSound = None
     self.__gearDamagedParam = None
     self.__manGearDamagedParam = None
     self.__gearKeyOffParam = None
     self.__stateTable = ((None,
       self.__startManualSound,
       self.__initHighSpeed,
       None),
      (self.__stopManualSound,
       None,
       self.__initHighSpeed,
       None),
      (self.__stopManualSound,
       self.__startManualSoundFromFast,
       None,
       None),
      (self.__stopGearSoundPlaying,
       self.__startManualSoundFromFast,
       None,
       self.__checkGearSound))
     self.__init_sound()
     return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 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

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, dataSec, aim):
     CallbackDelayer.__init__(self)
     TimeDeltaMeter.__init__(self)
     self.__shiftKeySensor = None
     self.__movementOscillator = None
     self.__impulseOscillator = None
     self.__noiseOscillator = None
     self.__dynamicCfg = CameraDynamicConfig()
     self.__accelerationSmoother = None
     self.__readCfg(dataSec)
     self.__cam = None
     self.__aim = None
     self.__onChangeControlMode = None
     self.__aimingSystem = None
     self.__curSense = 0
     self.__curScrollSense = 0
     self.__postmortemMode = False
     self.__vehiclesToCollideWith = set()
     self.__focalPointDist = 1.0
     self.__autoUpdateDxDyDz = Vector3(0.0)
     self.__defaultAimOffset = (0.0, 0.0)
     if aim is None:
         return
     else:
         self.__aim = weakref.proxy(aim)
         self.__cam = BigWorld.HomingCamera()
         aimOffset = self.__aim.offset()
         self.__cam.aimPointClipCoords = Vector2(aimOffset)
         self.__defaultAimOffset = (aimOffset[0], aimOffset[1])
         return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
    def __init__(self, dataSec, defaultOffset = None):
        CallbackDelayer.__init__(self)
        TimeDeltaMeter.__init__(self)
        self.__shiftKeySensor = None
        self.__movementOscillator = None
        self.__impulseOscillator = None
        self.__noiseOscillator = None
        self.__dynamicCfg = CameraDynamicConfig()
        self.__accelerationSmoother = None
        self.__readCfg(dataSec)
        self.__onChangeControlMode = None
        self.__aimingSystem = None
        self.__curSense = 0
        self.__curScrollSense = 0
        self.__postmortemMode = False
        self.__vehiclesToCollideWith = set()
        self.__focalPointDist = 1.0
        self.__autoUpdateDxDyDz = Vector3(0.0)
        self.__updatedByKeyboard = False
        if defaultOffset is not None:
            self.__defaultAimOffset = defaultOffset
            self.__cam = BigWorld.HomingCamera(self.__adCfg['enable'])
            if self.__adCfg['enable']:
                self.__cam.initAdvancedCollider(self.__adCfg['fovRatio'], self.__adCfg['rollbackSpeed'], self.__adCfg['minimalCameraDistance'], self.__adCfg['speedThreshold'], self.__adCfg['minimalVolume'])
                for group_name in VOLUME_GROUPS_NAMES:
                    self.__cam.addVolumeGroup(self.__adCfg['volumeGroups'][group_name])

            self.__cam.aimPointClipCoords = defaultOffset
        else:
            self.__defaultAimOffset = Vector2()
            self.__cam = None
        return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self):
     CallbackDelayer.__init__(self)
     ComponentSystem.__init__(self)
     self.turretMatrix = Math.WGAdaptiveMatrixProvider()
     self.gunMatrix = Math.WGAdaptiveMatrixProvider()
     self.__vehicle = None
     self.__filter = None
     self.__originalFilter = None
     self.__typeDesc = None
     self.__waterHeight = -1.0
     self.__isInWater = False
     self.__isUnderWater = False
     self.__splashedWater = False
     self.__vibrationsCtrl = None
     self.__lightFxCtrl = None
     self.__auxiliaryFxCtrl = None
     self.__fashion = None
     self.__crashedTracksCtrl = None
     self.__gunRecoil = None
     self.__currentDamageState = VehicleDamageState()
     self.__loadingProgress = 0
     self.__effectsPlayer = None
     self.__engineMode = (0, 0)
     self.__swingMoveFlags = 0
     self.__currTerrainMatKind = [-1] * _MATKIND_COUNT
     self.__leftLightRotMat = None
     self.__rightLightRotMat = None
     self.__leftFrontLight = None
     self.__rightFrontLight = None
     self.__prevVelocity = None
     self.__prevTime = None
     self.__isPillbox = False
     self.__chassisOcclusionDecal = OcclusionDecal()
     self.__chassisShadowForwardDecal = ShadowForwardDecal()
     self.__splodge = None
     self.__vehicleStickers = None
     self.onModelChanged = Event()
     self.__speedInfo = Math.Vector4(0.0, 0.0, 0.0, 0.0)
     self.__wasOnSoftTerrain = False
     self.__vehicleMatrixProv = None
     self.__leftTrackScroll = 0.0
     self.__rightTrackScroll = 0.0
     self.__distanceFromPlayer = 0.0
     self.__fashions = None
     self.__compoundModel = None
     self.__boundEffects = None
     self.__swingingAnimator = None
     self.__splineTracks = None
     self.__customEffectManager = None
     self.__trackScrollCtl = BigWorld.PyTrackScroll()
     self.__weaponEnergy = 0.0
     self.__activated = False
     self.__systemStarted = False
     self.__vID = 0
     self.__isAlive = True
     self.__isTurretDetached = False
     self.__trackFashionSet = False
     self.__periodicTimerID = None
     self.__wasDeactivated = False
     return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, dataSec, defaultOffset = None, binoculars = None):
     CallbackDelayer.__init__(self)
     self.__impulseOscillator = None
     self.__movementOscillator = None
     self.__noiseOscillator = None
     self.__dynamicCfg = CameraDynamicConfig()
     self.__accelerationSmoother = None
     self.__readCfg(dataSec)
     if 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.__binoculars = binoculars
         self.__defaultAimOffset = defaultOffset or Vector2()
         self.__crosshairMatrix = createCrosshairMatrix(offsetFromNearPlane=self.__dynamicCfg['aimMarkerDistance'])
         self.__prevTime = BigWorld.time()
         self.__autoUpdateDxDyDz = Vector3(0, 0, 0)
         if BattleReplay.g_replayCtrl.isPlaying:
             BattleReplay.g_replayCtrl.setDataCallback('applyZoom', self.__applyZoom)
         return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self):
     CallbackDelayer.__init__(self)
     self.__alwaysShowAimKey = None
     self.__showMarkersKey = None
     sec = self._readCfg()
     self.onCameraChanged = Event()
     self.onPostmortemVehicleChanged = Event()
     self.onSetReloading = Event()
     self.onSetReloadingPercents = Event()
     self.__isArenaStarted = False
     self.__isStarted = False
     self.__targeting = _Targeting()
     self.__vertScreenshotCamera = _VertScreenshotCamera()
     self.__ctrls = dict()
     self.__killerVehicleID = None
     self.__isAutorotation = True
     self.__prevModeAutorotation = None
     self.__isSPG = False
     self.__isATSPG = False
     self.__setupCtrls(sec)
     self.__curCtrl = self.__ctrls[_CTRLS_FIRST]
     self.ctrlModeName = _CTRLS_FIRST
     self.__isDetached = False
     self.__waitObserverCallback = None
     self.__observerVehicle = None
     return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, dataSec, defaultOffset = None):
     CallbackDelayer.__init__(self)
     TimeDeltaMeter.__init__(self)
     self.__shiftKeySensor = None
     self.__movementOscillator = None
     self.__impulseOscillator = None
     self.__noiseOscillator = None
     self.__dynamicCfg = CameraDynamicConfig()
     self.__accelerationSmoother = None
     self.__readCfg(dataSec)
     self.__onChangeControlMode = None
     self.__aimingSystem = None
     self.__curSense = 0
     self.__curScrollSense = 0
     self.__postmortemMode = False
     self.__vehiclesToCollideWith = set()
     self.__focalPointDist = 1.0
     self.__autoUpdateDxDyDz = Vector3(0.0)
     self.__updatedByKeyboard = False
     if defaultOffset is not None:
         self.__defaultAimOffset = defaultOffset
         self.__cam = BigWorld.HomingCamera()
         self.__cam.aimPointClipCoords = defaultOffset
     else:
         self.__defaultAimOffset = Vector2()
         self.__cam = None
     return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self):
     BigWorld.Entity.__init__(self)
     FlockLike.__init__(self)
     CallbackDelayer.__init__(self)
     self.flightAngleMin = math.radians(self.flightAngleMin)
     self.flightAngleMax = math.radians(self.flightAngleMax)
     if self.flightAngleMin < 0:
         self.flightAngleMin += math.ceil(abs(self.flightAngleMin) / (math.pi * 2)) * math.pi * 2
     elif self.flightAngleMin > math.pi * 2:
         self.flightAngleMin -= math.floor(self.flightAngleMin / (math.pi * 2)) * math.pi * 2
     self.__isTriggered = False
     self.__models = []

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self):
     if not constants.IS_DEVELOPMENT:
         return
     CallbackDelayer.__init__(self)
     self.__items = {}
     self.__avgInfo = {}
     self.__textGui = GUI.Text()
     GUI.addRoot(self.__textGui)
     self.__textGui.position = (0, -0.25, 0)
     self.__textGui.multiline = True
     self.clear()
     self.__tickNames = {}

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, beginExplosionPos, endExplosionPos, areaWidth, velocity):
     CallbackDelayer.__init__(self)
     self.model = BigWorld.Model("helpers/models/unit_cube.model")
     BigWorld.addModel(self.model)
     self.model.position = beginExplosionPos
     linearHomer = BigWorld.LinearHomer()
     self.model.addMotor(linearHomer)
     linearHomer.align = mathUtils.createSRTMatrix((areaWidth, 5, 1), (0.0, 0, 0), Vector3(0, 0, 0))
     linearHomer.acceleration = 0
     linearHomer.velocity = velocity
     linearHomer.target = mathUtils.createTranslationMatrix(endExplosionPos)
     linearHomer.proximityCallback = self.__onDeath

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, dataSection, avatarInputHandler):
     CallbackDelayer.__init__(self)
     self.__preferredPos = Vector3(0, 0, 0)
     self.__aih = weakref.proxy(avatarInputHandler)
     self.__cam = StrategicCamera.StrategicCamera(dataSection['camera'])
     self.__isEnabled = False
     self.__updateInterval = 0.1
     self.__activeSelector = _DefaultStrikeSelector(Vector3(0, 0, 0), None)
     self.__equipmentID = None
     self.__aimingMode = 0
     MapCaseControlMode.prevCtlMode = [Vector3(0, 0, 0), '', 0]
     return

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
    def __init__(self, equipmentID, wingControlPoints):
        CallbackDelayer.__init__(self)
        self.__withdrawn = False
        self.__bombers = []
        modelName, soundEvent = self.__readData(equipmentID)
        speed = self.__calculateSpeed(wingControlPoints[0], wingControlPoints[1])
        flatVectors = map(self.__calculateDirAndNorm, (wingControlPoints[0].direction, wingControlPoints[1].direction))
        times = map(self.__convertTime, (wingControlPoints[0].time, wingControlPoints[1].time))
        for offset in self.__offsets:
            points = []
            for i in xrange(2):
                point = wingControlPoints[i]
                realOffset = self.__calculateOffset(offset, flatVectors[i])
                points.append(CurveControlPoint(point.position + realOffset, speed * point.direction, times[i]))

            bomberDesc = BomberDesc(modelName, soundEvent, points[0], points[1])
            self.__bombers.append(Bomber(bomberDesc))

# 需要导入模块: from helpers.CallbackDelayer import CallbackDelayer [as 别名]
# 或者: from helpers.CallbackDelayer.CallbackDelayer import __init__ [as 别名]
 def __init__(self, physicsMode, isPlayerVehicle, modelsDesc, typeDesc, vehicleId):
     CallbackDelayer.__init__(self)
     self.__prevVelocity = 0
     self.__prevTime = 0.0
     self.__prevTerrSwitch = None
     self.__physicsMode = physicsMode
     self.__isPlayerVehicle = isPlayerVehicle
     self.__typeDesc = typeDesc
     self.__commonTrackScroll = 0.0
     self.__engineSound = None
     self.__movementSound = None
     self.__gunSound = None
     self.__modelsDesc = modelsDesc
     self.__vehicleId = vehicleId
     self.__event = None
     self.__eventC = None
     self.__cameraUnit = False
     self.__initSounds()
     BigWorld.player().inputHandler.onCameraChanged += self.__onCameraChanged
     return