def activate(self):
if self.__activated or self.__vehicle is None:
return
else:
if self.__currentDamageState.isCurrentModelDamaged:
if self.__customEffectManager is not None:
self.__customEffectManager.destroy()
self.__customEffectManager = None
if self.detailedEngineState is not None:
self.detailedEngineState.destroy()
self.detailedEngineState = None
super(CompoundAppearance, self).activate()
isPlayerVehicle = self.__vehicle.isPlayerVehicle
isObserver = 'observer' in self.__typeDesc.type.tags
player = BigWorld.player()
self.__originalFilter = self.__vehicle.filter
self.__createFilter()
self.__vehicle.filter = self.__filter
self.__vehicle.filter.enableNewPhysics(True)
self.__vehicle.filter.enableStabilisedMatrix(isPlayerVehicle)
self.__filter.isStrafing = self.__vehicle.isStrafing
self.__filter.vehicleCollisionCallback = player.handleVehicleCollidedVehicle
self.__compoundModel.isHighPriorityReflection = isPlayerVehicle
self.__vehicleMatrixProv = self.__compoundModel.matrix
if isPlayerVehicle:
if player.inputHandler is not None:
player.inputHandler.addVehicleToCameraCollider(self.__vehicle)
BigWorld.setSpeedTreeCollisionBody(self.__compoundModel.getBoundsForPart(TankPartIndexes.HULL))
self.__linkCompound()
self.__chassisShadowForwardDecal.attach(self.__typeDesc, self.__compoundModel)
if not isObserver:
self.__chassisOcclusionDecal.attach(self.__typeDesc, self.__compoundModel)
self.__createStickers()
if self.__currentDamageState.isCurrentModelDamaged:
self.__attachStickers(items.vehicles.g_cache.commonConfig['miscParams']['damageStickerAlpha'], True)
else:
self.__startSystems()
self.__attachStickers()
self.setupGunMatrixTargets()
if not isObserver:
self.__vehicle.filter.enableLagDetection(True)
self.onModelChanged()
if self.lodCalculator is not None:
self.lodCalculator.setupPosition(DataLinks.linkMatrixTranslation(self.__compoundModel.matrix))
if hasattr(self.filter, 'placingCompensationMatrix') and self.swingingAnimator is not None:
self.swingingAnimator.placingCompensationMatrix = self.filter.placingCompensationMatrix
self.swingingAnimator.worldMatrix = self.__compoundModel.matrix
if self.__periodicTimerID is not None:
BigWorld.cancelCallback(self.__periodicTimerID)
self.__periodicTimerID = BigWorld.callback(_PERIODIC_TIME, self.__onPeriodicTimer)
self.__activated = True
if 'observer' in self.__vehicle.typeDescriptor.type.tags:
self.__compoundModel.visible = False
if self.__currentDamageState.isCurrentModelDamaged:
if not self.__wasDeactivated:
if not self.__vehicle.isPlayerVehicle:
self.setupGunMatrixTargets()
else:
self.setupGunMatrixTargets(self.__vehicle.filter)
return
def activate(self):
if self.collisions is not None and self.isTurretDetached:
self.collisions.removeAttachment(TankPartNames.getIdx(TankPartNames.TURRET))
self.collisions.removeAttachment(TankPartNames.getIdx(TankPartNames.GUN))
super(CommonTankAppearance, self).activate()
if not self.isObserver:
self._chassisDecal.attach()
self._createAndAttachStickers()
if not self.isObserver:
if not self.damageState.isCurrentModelDamaged and not self.__systemStarted:
self._startSystems()
self.filter.enableLagDetection(not self.damageState.isCurrentModelDamaged)
if self.__periodicTimerID is not None:
BigWorld.cancelCallback(self.__periodicTimerID)
self.__periodicTimerID = BigWorld.callback(PERIODIC_UPDATE_TIME, self.__onPeriodicTimer)
self.setupGunMatrixTargets(self.filter)
for lodCalculator in self.allLodCalculators:
lodCalculator.setupPosition(DataLinks.linkMatrixTranslation(self.compoundModel.matrix))
for modelAnimator in self.__modelAnimators:
modelAnimator.animator.start()
if hasattr(self.filter, 'placingCompensationMatrix') and self.swingingAnimator is not None:
self.swingingAnimator.placingCompensationMatrix = self.filter.placingCompensationMatrix
self.swingingAnimator.worldMatrix = self.compoundModel.matrix
if self.isObserver:
self.compoundModel.visible = False
if self.collisions is not None:
chassisColisionMatrix, gunNodeName = self._vehicleColliderInfo
collisionData = ((TankPartNames.getIdx(TankPartNames.HULL), self.compoundModel.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.TURRET), self.compoundModel.node(TankPartNames.TURRET)),
(TankPartNames.getIdx(TankPartNames.CHASSIS), chassisColisionMatrix),
(TankPartNames.getIdx(TankPartNames.GUN), self.compoundModel.node(gunNodeName)))
self.collisions.connect(self.id, ColliderTypes.VEHICLE_COLLIDER, collisionData)
return
def activate(self):
typeDescr = self.typeDescriptor
wheelConfig = typeDescr.chassis.generalWheelsAnimatorConfig
if self.wheelsAnimator is not None and wheelConfig is not None:
self.wheelsAnimator.createCollision(wheelConfig, self.collisions)
super(CommonTankAppearance, self).activate()
self.wheelsGameObject.activate()
for go in self.filterRetrieverGameObjects:
go.activate()
if not self.isObserver:
self._chassisDecal.attach()
if not self.isObserver:
self._startSystems()
self.filter.enableLagDetection(not self.damageState.isCurrentModelDamaged)
if self.__periodicTimerID is not None:
BigWorld.cancelCallback(self.__periodicTimerID)
self.__periodicTimerID = BigWorld.callback(PERIODIC_UPDATE_TIME, self.__onPeriodicTimer)
self.setupGunMatrixTargets(self.filter)
for lodCalculator in self.allLodCalculators:
lodCalculator.setupPosition(DataLinks.linkMatrixTranslation(self.compoundModel.matrix))
for modelAnimator in self.__modelAnimators:
modelAnimator.animator.setEnabled(True)
modelAnimator.animator.start()
if hasattr(self.filter, 'placingCompensationMatrix') and self.swingingAnimator is not None:
self.swingingAnimator.placingCompensationMatrix = self.filter.placingCompensationMatrix
self.swingingAnimator.worldMatrix = self.compoundModel.matrix
if self.isObserver:
self.compoundModel.visible = False
self._connectCollider()
self._attachStickers()
return
def _assembleParts(self, isPlayer, appearance):
if appearance.isAlive:
appearance.detailedEngineState = self.__assembleEngineState(
isPlayer)
if not appearance.isPillbox and not gEffectsDisabled():
appearance.engineAudition = self.__assembleEngineAudition(
isPlayer, appearance)
appearance.detailedEngineState.onEngineStart += appearance.engineAudition.onEngineStart
appearance.detailedEngineState.onStateChanged += appearance.engineAudition.onStateChanged
createEffects(appearance)
if isPlayer:
gunRotatorConnector = GunRotatorConnector(appearance)
appearance.addComponent(gunRotatorConnector)
appearance.frictionAudition = Vehicular.FrictionAudition(
TANK_FRICTION_EVENT)
self.__createTrackCrashControl(appearance)
appearance.highlighter = Highlighter()
isLodTopPriority = isPlayer
lodCalcInst = Vehicular.LodCalculator(
DataLinks.linkMatrixTranslation(appearance.compoundModel.matrix),
True, VEHICLE_PRIORITY_GROUP, isLodTopPriority)
appearance.lodCalculator = lodCalcInst
lodLink = DataLinks.createFloatLink(lodCalcInst, 'lodDistance')
lodStateLink = lodCalcInst.lodStateLink
if not appearance.damageState.isCurrentModelDamaged:
model_assembler.assembleRecoil(appearance, lodLink)
model_assembler.assembleLeveredSuspensionIfNeed(
appearance, lodStateLink)
_assembleSwinging(appearance, lodLink)
model_assembler.assembleSuspensionSound(appearance, lodLink,
isPlayer)
model_assembler.assembleSuspensionController(appearance)
model_assembler.setupTurretRotations(appearance)
def activate(self):
if self.__activated or self.__vehicle is None:
return
else:
super(CompoundAppearance, self).activate()
isPlayerVehicle = self.__vehicle.isPlayerVehicle
isObserver = 'observer' in self.__typeDesc.type.tags
player = BigWorld.player()
self.__originalFilter = self.__vehicle.filter
self.__vehicle.filter = self.__filter
self.__vehicle.filter.enableStabilisedMatrix(isPlayerVehicle)
self.__filter.isStrafing = self.__vehicle.isStrafing
self.__filter.vehicleCollisionCallback = player.handleVehicleCollidedVehicle
self.__compoundModel.isHighPriorityReflection = isPlayerVehicle
if isPlayerVehicle:
if player.inputHandler is not None:
player.inputHandler.addVehicleToCameraCollider(
self.__vehicle)
self.__inSpeedTreeCollision = True
BigWorld.setSpeedTreeCollisionBody(
self.__compoundModel.getBoundsForPart(
TankPartIndexes.HULL))
self.__linkCompound()
if not isObserver:
self.__chassisDecal.attach()
self.__createAndAttachStickers()
self.__startSystems()
self.setupGunMatrixTargets()
if not isObserver:
self.__vehicle.filter.enableLagDetection(
not self.__currentDamageState.isCurrentModelDamaged)
self.onModelChanged()
if self.lodCalculator is not None:
self.lodCalculator.setupPosition(
DataLinks.linkMatrixTranslation(
self.__compoundModel.matrix))
if hasattr(self.filter, 'placingCompensationMatrix'
) and self.swingingAnimator is not None:
self.swingingAnimator.placingCompensationMatrix = self.filter.placingCompensationMatrix
self.swingingAnimator.worldMatrix = self.__compoundModel.matrix
if self.__periodicTimerID is not None:
BigWorld.cancelCallback(self.__periodicTimerID)
self.__periodicTimerID = BigWorld.callback(_PERIODIC_TIME,
self.__onPeriodicTimer)
if self.fashion is not None:
self.fashion.activate()
if isObserver:
self.__compoundModel.visible = False
BigWorld.player().arena.onPeriodChange += self.__arenaPeriodChanged
BigWorld.player(
).inputHandler.onCameraChanged += self.__onCameraChanged
if self.detailedEngineState is not None:
engine_state.checkEngineStart(self.detailedEngineState,
BigWorld.player().arena.period)
self.__activated = True
return
def _assembleParts(self, isPlayer, appearance):
appearance.filter = model_assembler.createVehicleFilter(
appearance.typeDescriptor)
if appearance.isAlive:
appearance.detailedEngineState = model_assembler.assembleDetailedEngineState(
appearance.compoundModel, appearance.filter,
appearance.typeDescriptor, isPlayer)
if not gEffectsDisabled():
model_assembler.assembleVehicleAudition(isPlayer, appearance)
model_assembler.subscribeEngineAuditionToEngineState(
appearance.engineAudition, appearance.detailedEngineState)
createEffects(appearance)
if isPlayer:
gunRotatorConnector = GunRotatorConnector(appearance)
appearance.addComponent(gunRotatorConnector)
appearance.frictionAudition = Vehicular.FrictionAudition(
TANK_FRICTION_EVENT)
appearance.peripheralsController = PeripheralsController()
self.__createTrackCrashControl(appearance)
appearance.highlighter = Highlighter()
isLodTopPriority = isPlayer
lodCalcInst = Vehicular.LodCalculator(
DataLinks.linkMatrixTranslation(appearance.compoundModel.matrix),
True, VEHICLE_PRIORITY_GROUP, isLodTopPriority)
appearance.lodCalculator = lodCalcInst
lodLink = DataLinks.createFloatLink(lodCalcInst, 'lodDistance')
lodStateLink = lodCalcInst.lodStateLink
isDamaged = appearance.damageState.isCurrentModelDamaged
if not isDamaged:
self.__assembleNonDamagedOnly(appearance, isPlayer, lodLink,
lodStateLink)
model_assembler.setupTurretRotations(appearance)
if appearance.fashion is not None:
appearance.fashion.movementInfo = appearance.filter.movementInfo
appearance.waterSensor = model_assembler.assembleWaterSensor(
appearance.typeDescriptor, appearance, lodStateLink)
if appearance.engineAudition is not None:
appearance.engineAudition.setIsUnderwaterInfo(
DataLinks.createBoolLink(appearance.waterSensor,
'isUnderWater'))
appearance.engineAudition.setIsInWaterInfo(
DataLinks.createBoolLink(appearance.waterSensor, 'isInWater'))
if isPlayer and BigWorld.player().isInTutorial:
tutorialMatKindsController = TutorialMatKindsController()
tutorialMatKindsController.terrainMatKindsLink = lambda: appearance.terrainMatKind
appearance.addComponent(tutorialMatKindsController)
self.__postSetupFilter(appearance)
return
def __assembleNonDamagedOnly(self, resourceRefs, isPlayer, lodLink, lodStateLink):
model_assembler.assembleTerrainMatKindSensor(self, lodStateLink, self.worldID)
model_assembler.assembleRecoil(self, lodLink)
model_assembler.assembleMultiGunRecoil(self, lodLink)
model_assembler.assembleGunLinkedNodesAnimator(self)
model_assembler.assembleCollisionObstaclesCollector(self, lodStateLink, self.typeDescriptor, self.worldID)
model_assembler.assembleTessellationCollisionSensor(self, lodStateLink)
wheelsScroll = None
wheelsSteering = None
generalWheelsAnimatorConfig = self.typeDescriptor.chassis.generalWheelsAnimatorConfig
if generalWheelsAnimatorConfig is not None:
scrollableWheelsCount = generalWheelsAnimatorConfig.getNonTrackWheelsCount()
wheelsScroll = []
for _ in xrange(scrollableWheelsCount):
retriever = self.createComponent(NetworkFilters.FloatFilterRetriever)
wheelsScroll.append(DataLinks.createFloatLink(retriever, 'value'))
self.filterRetrievers.append(retriever)
steerableWheelsCount = generalWheelsAnimatorConfig.getSteerableWheelsCount()
wheelsSteering = []
for _ in xrange(steerableWheelsCount):
retriever = self.createComponent(NetworkFilters.FloatFilterRetriever)
wheelsSteering.append(DataLinks.createFloatLink(retriever, 'value'))
self.filterRetrievers.append(retriever)
self.wheelsAnimator = model_assembler.createWheelsAnimator(self, ColliderTypes.VEHICLE_COLLIDER, self.typeDescriptor, lambda : self.wheelsState, wheelsScroll, wheelsSteering, self.splineTracks, lodStateLink)
if self.customEffectManager is not None:
self.customEffectManager.setWheelsData(self)
suspensionLodLink = lodStateLink
if 'wheeledVehicle' in self.typeDescriptor.type.tags:
wheeledLodCalculator = Vehicular.LodCalculator(self.worldID, DataLinks.linkMatrixTranslation(self.compoundModel.matrix), True, WHEELED_CHASSIS_PRIORITY_GROUP, isPlayer)
self.wheeledLodCalculator = wheeledLodCalculator
self.allLodCalculators.append(wheeledLodCalculator)
suspensionLodLink = wheeledLodCalculator.lodStateLink
model_assembler.assembleSuspensionIfNeed(self, suspensionLodLink)
model_assembler.assembleLeveredSuspensionIfNeed(self, suspensionLodLink)
self.__assembleSwinging(lodLink)
model_assembler.assembleBurnoutProcessor(self)
model_assembler.assembleSuspensionSound(self, lodLink, isPlayer)
model_assembler.assembleHullAimingController(self)
self.trackNodesAnimator = model_assembler.createTrackNodesAnimator(self, self.typeDescriptor, lodStateLink)
model_assembler.assembleTracks(resourceRefs, self.typeDescriptor, self, self.splineTracks, False, lodStateLink)
model_assembler.assembleVehicleTraces(self, self.filter, lodStateLink)
return
def _assembleParts(self, isPlayer, appearance):
if appearance.isAlive:
appearance.detailedEngineState = self.__assembleEngineState(isPlayer)
if not appearance.isPillbox and not gEffectsDisabled():
appearance.engineAudition = self.__assembleEngineAudition(isPlayer, appearance)
appearance.detailedEngineState.onEngineStart += appearance.engineAudition.onEngineStart
appearance.detailedEngineState.onStateChanged += appearance.engineAudition.onStateChanged
_createEffects(appearance)
if isPlayer:
gunRotatorConnector = GunRotatorConnector(appearance)
appearance.addComponent(gunRotatorConnector)
self.__createTrackCrashControl(appearance)
appearance.highlighter = Highlighter()
lodCalcInst = Vehicular.LodCalculator(DataLinks.linkMatrixTranslation(appearance.compoundModel.matrix), True)
appearance.lodCalculator = lodCalcInst
lodLink = DataLinks.createFloatLink(lodCalcInst, 'lodDistance')
if not appearance.damageState.isCurrentModelDamaged:
model_assembler.assembleRecoil(appearance, lodLink)
_assembleSwinging(appearance, lodLink)
model_assembler.setupTurretRotations(appearance)
def _assembleParts(self, isPlayer, appearance):
if appearance.isAlive:
appearance.detailedEngineState = self.__assembleEngineState(
isPlayer)
if not appearance.isPillbox and not gEffectsDisabled():
appearance.engineAudition = self.__assembleEngineAudition(
isPlayer, appearance)
appearance.detailedEngineState.onEngineStart += appearance.engineAudition.onEngineStart
appearance.detailedEngineState.onStateChanged += appearance.engineAudition.onStateChanged
_createEffects(appearance)
if isPlayer:
gunRotatorConnector = GunRotatorConnector(appearance)
appearance.addComponent(gunRotatorConnector)
self.__createTrackCrashControl(appearance)
appearance.highlighter = Highlighter()
lodCalcInst = Vehicular.LodCalculator(
DataLinks.linkMatrixTranslation(appearance.compoundModel.matrix),
True)
appearance.lodCalculator = lodCalcInst
lodLink = DataLinks.createFloatLink(lodCalcInst, 'lodDistance')
if not appearance.damageState.isCurrentModelDamaged:
model_assembler.assembleRecoil(appearance, lodLink)
_assembleSwinging(appearance, lodLink)
model_assembler.setupTurretRotations(appearance)
def construct(self, isPlayer, resourceRefs):
self.__isObserver = 'observer' in self.typeDescriptor.type.tags
self._compoundModel = resourceRefs[self.typeDescriptor.name]
self.removeComponentByType(GenericComponents.DynamicModelComponent)
self.createComponent(GenericComponents.DynamicModelComponent,
self._compoundModel)
if not self._compoundModel.isValid():
_logger.error('compoundModel is not valid')
if self.typeDescriptor.gun.edgeByVisualModel:
self._compoundModel.setPartProperties(
TankPartIndexes.GUN, PartProperties.HIGHLIGHTABLE
| PartProperties.HIGHLIGHTBYVISUAL)
self._compoundModel.setPartProperties(
TankPartIndexes.CHASSIS,
PartProperties.HIGHLIGHTABLE | PartProperties.HIGHLIGHTBYVISUAL)
self.__boundEffects = bound_effects.ModelBoundEffects(
self.compoundModel)
isCurrentModelDamaged = self.damageState.isCurrentModelDamaged
fashions = camouflages.prepareFashions(isCurrentModelDamaged)
if not isCurrentModelDamaged:
model_assembler.setupTracksFashion(self.typeDescriptor,
fashions.chassis)
self.collisions = self.createComponent(
BigWorld.CollisionComponent, resourceRefs['collisionAssembler'])
model_assembler.setupCollisions(self.typeDescriptor, self.collisions)
self._setFashions(fashions, self.isTurretDetached)
self._setupModels()
if not isCurrentModelDamaged:
modelsSet = self.outfit.modelsSet
if IS_EDITOR:
modelsSet = self.currentModelsSet
self._splineTracks = model_assembler.setupSplineTracks(
self.fashion, self.typeDescriptor, self.compoundModel,
resourceRefs, modelsSet)
self.crashedTracksController = CrashedTrackController(
self.typeDescriptor, self.fashion, modelsSet)
else:
self.__trackScrollCtl = None
self._chassisDecal.create()
if self.modelsSetParams.state == 'undamaged':
self.__modelAnimators = camouflages.getModelAnimators(
self.outfit, self.typeDescriptor, self.spaceID, resourceRefs,
self.compoundModel)
self.__modelAnimators.extend(
camouflages.getAttachmentsAnimators(self.__attachments,
self.spaceID, resourceRefs,
self.compoundModel))
self.transform = self.createComponent(
GenericComponents.TransformComponent, Math.Vector3(0, 0, 0))
self.areaTriggerTarget = self.createComponent(
Triggers.AreaTriggerTarget)
self.__filter = model_assembler.createVehicleFilter(
self.typeDescriptor)
compoundModel = self.compoundModel
if self.isAlive:
self.detailedEngineState, self.gearbox = model_assembler.assembleDrivetrain(
self, isPlayer)
if not gEffectsDisabled():
self.customEffectManager = CustomEffectManager(self)
if self.typeDescriptor.hasSiegeMode:
self.siegeEffects = SiegeEffectsController(self, isPlayer)
model_assembler.assembleVehicleAudition(isPlayer, self)
self.detailedEngineState.onEngineStart = self._onEngineStart
self.detailedEngineState.onStateChanged = self.engineAudition.onEngineStateChanged
if isPlayer:
turret = self.typeDescriptor.turret
gunRotatorAudition = self.createComponent(
Vehicular.GunRotatorAudition,
turret.turretRotatorSoundManual, turret.weight / 1000.0,
compoundModel.node(TankPartNames.TURRET))
gunRotatorAudition.vehicleMatrixLink = self.compoundModel.root
gunRotatorAudition.damaged = lambda: self.turretDamaged()
gunRotatorAudition.maxTurretRotationSpeed = lambda: self.maxTurretRotationSpeed(
)
self.gunRotatorAudition = gunRotatorAudition
self.frictionAudition = self.createComponent(
Vehicular.FrictionAudition, TANK_FRICTION_EVENT)
isLodTopPriority = isPlayer
lodCalcInst = self.createComponent(
Vehicular.LodCalculator,
DataLinks.linkMatrixTranslation(compoundModel.matrix), True,
VEHICLE_PRIORITY_GROUP, isLodTopPriority)
self.lodCalculator = lodCalcInst
self.allLodCalculators.append(lodCalcInst)
lodLink = DataLinks.createFloatLink(lodCalcInst, 'lodDistance')
lodStateLink = lodCalcInst.lodStateLink
if IS_EDITOR:
matrixBinding = None
changeCamera = None
else:
matrixBinding = BigWorld.player(
).consistentMatrices.onVehicleMatrixBindingChanged
changeCamera = BigWorld.player().inputHandler.onCameraChanged
self.shadowManager = VehicleShadowManager(compoundModel, matrixBinding,
changeCamera)
if not self.damageState.isCurrentModelDamaged:
self.__assembleNonDamagedOnly(resourceRefs, isPlayer, lodLink,
lodStateLink)
dirtEnabled = BigWorld.WG_dirtEnabled(
) and 'HD' in self.typeDescriptor.type.tags
if dirtEnabled and self.fashions is not None:
dirtHandlers = [
BigWorld.PyDirtHandler(
True,
compoundModel.node(TankPartNames.CHASSIS).position.y),
BigWorld.PyDirtHandler(
False,
compoundModel.node(TankPartNames.HULL).position.y),
BigWorld.PyDirtHandler(
False,
compoundModel.node(TankPartNames.TURRET).position.y),
BigWorld.PyDirtHandler(
False,
compoundModel.node(TankPartNames.GUN).position.y)
]
modelHeight, _ = self.computeVehicleHeight()
self.dirtComponent = self.createComponent(
Vehicular.DirtComponent, dirtHandlers, modelHeight)
for fashionIdx, _ in enumerate(TankPartNames.ALL):
self.fashions[fashionIdx].addMaterialHandler(
dirtHandlers[fashionIdx])
self.fashions[fashionIdx].addTrackMaterialHandler(
dirtHandlers[fashionIdx])
model_assembler.setupTurretRotations(self)
self.waterSensor = model_assembler.assembleWaterSensor(
self.typeDescriptor, self, lodStateLink, self.spaceID)
if self.engineAudition is not None:
self.engineAudition.setIsUnderwaterInfo(
DataLinks.createBoolLink(self.waterSensor, 'isUnderWater'))
self.engineAudition.setIsInWaterInfo(
DataLinks.createBoolLink(self.waterSensor, 'isInWater'))
self.__postSetupFilter()
compoundModel.setPartBoundingBoxAttachNode(
TankPartIndexes.GUN, TankNodeNames.GUN_INCLINATION)
camouflages.updateFashions(self)
model_assembler.assembleCustomLogicComponents(self,
self.typeDescriptor,
self.__attachments,
self.__modelAnimators)
self._createStickers()
while self._loadingQueue:
prefab, go, vector, callback = self._loadingQueue.pop()
CGF.loadGameObjectIntoHierarchy(prefab, go, vector, callback)
return
def activate(self):
if self.__activated or self.__vehicle is None:
return
else:
if self.collisions is not None and self.__vehicle.isTurretDetached:
self.collisions.removeAttachment(
TankPartNames.getIdx(TankPartNames.TURRET))
self.collisions.removeAttachment(
TankPartNames.getIdx(TankPartNames.GUN))
super(CompoundAppearance, self).activate()
isPlayerVehicle = self.__vehicle.isPlayerVehicle
self.__isObserver = 'observer' in self.__typeDesc.type.tags
player = BigWorld.player()
self.__originalFilter = self.__vehicle.filter
self.__vehicle.filter = self.__filter
self.__vehicle.filter.enableStabilisedMatrix(isPlayerVehicle)
self.__filter.isStrafing = self.__vehicle.isStrafing
self.__filter.vehicleCollisionCallback = player.handleVehicleCollidedVehicle
if isPlayerVehicle and self.collisions is not None:
colliderData = (self.collisions.getColliderID(),
(TankPartNames.getIdx(TankPartNames.HULL),
TankPartNames.getIdx(TankPartNames.TURRET)))
BigWorld.appendCameraCollider(colliderData)
self.__inSpeedTreeCollision = True
BigWorld.setSpeedTreeCollisionBody(
self.__compoundModel.getBoundsForPart(
TankPartIndexes.HULL))
self.__linkCompound()
if not self.__isObserver:
self.__chassisDecal.attach()
self.__createAndAttachStickers()
if self.__currentDamageState.isCurrentModelDamaged:
self.__chassisColisionMatrix.target = self.__compoundModel.matrix
gunNodeName = 'gun'
else:
self.__chassisColisionMatrix.target = self.__vehicle.filter.groundPlacingMatrix
gunNodeName = TankNodeNames.GUN_INCLINATION
if not self.__isObserver:
self.__startSystems()
self.setupGunMatrixTargets()
if not self.__isObserver:
self.__vehicle.filter.enableLagDetection(
not self.__currentDamageState.isCurrentModelDamaged)
self.onModelChanged()
if self.lodCalculator is not None:
self.lodCalculator.setupPosition(
DataLinks.linkMatrixTranslation(
self.__compoundModel.matrix))
if hasattr(self.filter, 'placingCompensationMatrix'
) and self.swingingAnimator is not None:
self.swingingAnimator.placingCompensationMatrix = self.filter.placingCompensationMatrix
self.swingingAnimator.worldMatrix = self.__compoundModel.matrix
if not self.__isObserver:
if self.__periodicTimerID is not None:
BigWorld.cancelCallback(self.__periodicTimerID)
self.__periodicTimerID = BigWorld.callback(
_PERIODIC_TIME, self.__onPeriodicTimer)
self.__dirtUpdateTime = BigWorld.time()
if self.fashion is not None:
self.fashion.activate()
if self.__isObserver:
self.__compoundModel.visible = False
BigWorld.player().arena.onPeriodChange += self.__arenaPeriodChanged
BigWorld.player(
).inputHandler.onCameraChanged += self.__onCameraChanged
if self.detailedEngineState is not None:
engine_state.checkEngineStart(self.detailedEngineState,
BigWorld.player().arena.period)
if self.collisions is not None:
collisionData = ((TankPartNames.getIdx(TankPartNames.HULL),
self.compoundModel.node(TankPartNames.HULL)),
(TankPartNames.getIdx(TankPartNames.TURRET),
self.compoundModel.node(
TankPartNames.TURRET)),
(TankPartNames.getIdx(TankPartNames.CHASSIS),
self.__chassisColisionMatrix),
(TankPartNames.getIdx(TankPartNames.GUN),
self.compoundModel.node(gunNodeName)))
self.collisions.connect(self.id,
ColliderTypes.VEHICLE_COLLIDER,
collisionData)
self.__activated = True
return
def _assembleParts(self, isPlayer, appearance, resourceRefs):
appearance.filter = model_assembler.createVehicleFilter(
appearance.typeDescriptor)
if appearance.isAlive:
appearance.detailedEngineState = model_assembler.assembleDetailedEngineState(
appearance.compoundModel, appearance.filter,
appearance.typeDescriptor, isPlayer)
if not gEffectsDisabled():
model_assembler.assembleVehicleAudition(isPlayer, appearance)
model_assembler.subscribeEngineAuditionToEngineState(
appearance.engineAudition, appearance.detailedEngineState)
createEffects(appearance)
if isPlayer:
gunRotatorConnector = GunRotatorConnector(appearance)
appearance.addComponent(gunRotatorConnector)
appearance.frictionAudition = Vehicular.FrictionAudition(
TANK_FRICTION_EVENT)
appearance.peripheralsController = PeripheralsController()
self.__createTrackCrashControl(appearance)
appearance.highlighter = Highlighter()
compoundModel = appearance.compoundModel
isLodTopPriority = isPlayer
lodCalcInst = Vehicular.LodCalculator(
DataLinks.linkMatrixTranslation(appearance.compoundModel.matrix),
True, VEHICLE_PRIORITY_GROUP, isLodTopPriority)
appearance.lodCalculator = lodCalcInst
lodLink = DataLinks.createFloatLink(lodCalcInst, 'lodDistance')
lodStateLink = lodCalcInst.lodStateLink
matrixBinding = BigWorld.player(
).consistentMatrices.onVehicleMatrixBindingChanged
appearance.shadowManager = VehicleShadowManager(
compoundModel, matrixBinding)
isDamaged = appearance.damageState.isCurrentModelDamaged
if not isDamaged:
self.__assembleNonDamagedOnly(appearance, isPlayer, lodLink,
lodStateLink)
dirtEnabled = BigWorld.WG_dirtEnabled(
) and 'HD' in appearance.typeDescriptor.type.tags
fashions = appearance.fashions
if dirtEnabled and fashions is not None:
dirtHandlers = [
BigWorld.PyDirtHandler(
True,
compoundModel.node(TankPartNames.CHASSIS).position.y),
BigWorld.PyDirtHandler(
False,
compoundModel.node(TankPartNames.HULL).position.y),
BigWorld.PyDirtHandler(
False,
compoundModel.node(TankPartNames.TURRET).position.y),
BigWorld.PyDirtHandler(
False,
compoundModel.node(TankPartNames.GUN).position.y)
]
modelHeight, _ = appearance.computeVehicleHeight()
appearance.dirtComponent = Vehicular.DirtComponent(
dirtHandlers, modelHeight)
for fashionIdx, _ in enumerate(TankPartNames.ALL):
fashions[fashionIdx].addMaterialHandler(
dirtHandlers[fashionIdx])
model_assembler.setupTurretRotations(appearance)
if appearance.fashion is not None:
appearance.fashion.movementInfo = appearance.filter.movementInfo
appearance.waterSensor = model_assembler.assembleWaterSensor(
appearance.typeDescriptor, appearance, lodStateLink)
if appearance.engineAudition is not None:
appearance.engineAudition.setIsUnderwaterInfo(
DataLinks.createBoolLink(appearance.waterSensor,
'isUnderWater'))
appearance.engineAudition.setIsInWaterInfo(
DataLinks.createBoolLink(appearance.waterSensor, 'isInWater'))
if isPlayer and BigWorld.player().isInTutorial:
tutorialMatKindsController = TutorialMatKindsController()
tutorialMatKindsController.terrainMatKindsLink = lambda: appearance.terrainMatKind
appearance.addComponent(tutorialMatKindsController)
self.__postSetupFilter(appearance)
compoundModel.setPartBoundingBoxAttachNode(
TankPartIndexes.GUN, TankNodeNames.GUN_INCLINATION)
return
