def assembleVehicleTraces(appearance, f, lodStateLink=None):
vehicleTraces = Vehicular.VehicleTraces()
tracesConfig = appearance.typeDescriptor.chassis.traces
textures = {}
for matKindName, texId in DecalMap.g_instance.getTextureSet(
tracesConfig.textureSet).iteritems():
if matKindName != 'bump':
for matKind in material_kinds.EFFECT_MATERIAL_IDS_BY_NAMES[
matKindName]:
textures[matKind] = texId
vehicleTraces.setTrackTraces(
tracesConfig.bufferPrefs, textures, tracesConfig.centerOffset,
tracesConfig.size,
appearance.typeDescriptor.chassis.topRightCarryingPoint[1] * 2)
vehicleTraces.setCompound(appearance.compoundModel)
isLeftFlying = DataLinks.createBoolLink(appearance.flyingInfoProvider,
'isLeftSideFlying')
isRightFlying = DataLinks.createBoolLink(appearance.flyingInfoProvider,
'isRightSideFlying')
vehicleTraces.setFlyingInfo(isLeftFlying, isRightFlying)
vehicleTraces.setLodLink(lodStateLink)
vehicleTraces.setLodSettings(
shared_components.LodSettings(tracesConfig.lodDist,
DEFAULT_MAX_LOD_PRIORITY))
vehicleTraces.setMovementInfo(f.movementInfo)
appearance.vehicleTraces = vehicleTraces
def assembleVehicleTraces(appearance, f, lodStateLink=None):
vehicleTraces = appearance.createComponent(Vehicular.VehicleTraces)
chassisConfig = appearance.typeDescriptor.chassis
tracesConfig = chassisConfig.traces
textures = {}
for matKindName, texId in DecalMap.g_instance.getTextureSet(tracesConfig.textureSet).iteritems():
if matKindName != 'bump':
for matKind in material_kinds.EFFECT_MATERIAL_IDS_BY_NAMES[matKindName]:
textures[matKind] = texId
vehicleTraces.setTrackTextures(textures)
vehicleTraces.setCompound(appearance.compoundModel)
if chassisConfig.generalWheelsAnimatorConfig is None:
wrOffset = Math.Vector2(tracesConfig.centerOffset, 0)
wlOffset = Math.Vector2(-tracesConfig.centerOffset, 0)
length = appearance.typeDescriptor.chassis.topRightCarryingPoint[1] * 2
vehicleTraces.addTrackTrace('', wrOffset, tracesConfig.size, length, tracesConfig.bufferPrefs, False)
vehicleTraces.addTrackTrace('', wlOffset, tracesConfig.size, length, tracesConfig.bufferPrefs, False)
else:
traceConfigs = appearance.wheelsAnimator.getTraceConfigs()
for trace in traceConfigs:
vehicleTraces.addTrackTrace('', trace[0], tracesConfig.size, trace[1], tracesConfig.bufferPrefs, False)
isLeftFlying = DataLinks.createBoolLink(appearance.flyingInfoProvider, 'isLeftSideFlying')
isRightFlying = DataLinks.createBoolLink(appearance.flyingInfoProvider, 'isRightSideFlying')
vehicleTraces.setFlyingInfo(isLeftFlying, isRightFlying)
vehicleTraces.setLodLink(lodStateLink)
vehicleTraces.setLodSettings(shared_components.LodSettings(tracesConfig.lodDist, DEFAULT_MAX_LOD_PRIORITY))
vehicleTraces.setMovementInfo(f.movementInfo)
vehicleTraces.setActivePostmortem(tracesConfig.activePostmortem)
appearance.vehicleTraces = vehicleTraces
return
def __init__(self, spaceID):
ScriptGameObject.__init__(self, spaceID, CgfTankNodes.TANK_ROOT)
self._vehicle = None
self.__wheelsGameObject = ScriptGameObject(spaceID, 'Tank.Wheels.Root')
self.__filter = None
self.__typeDesc = None
self.crashedTracksController = None
self.__currentDamageState = VehicleDamageState()
self.__currTerrainMatKind = [-1] * MATKIND_COUNT
self.__currTerrainGroundType = [-1] * MATKIND_COUNT
self.__terrainEffectMaterialNames = [''] * MATKIND_COUNT
self._chassisDecal = VehicleDecal(self)
self.__splodge = None
self.__boundEffects = None
self._splineTracks = None
self.flyingInfoProvider = self.createComponent(
Vehicular.FlyingInfoProvider)
self.__trackScrollCtl = BigWorld.PyTrackScroll()
self.__trackScrollCtl.setFlyingInfo(
DataLinks.createBoolLink(self.flyingInfoProvider,
'isLeftSideFlying'),
DataLinks.createBoolLink(self.flyingInfoProvider,
'isRightSideFlying'))
self.__weaponEnergy = 0.0
self.__outfit = None
self.__systemStarted = False
self.__isAlive = True
self._isTurretDetached = False
self.__isObserver = False
self.__attachments = []
self.__modelAnimators = []
self.turretMatrix = None
self.gunMatrix = None
self.__allLodCalculators = []
self._commonScroll = 0.0
self._commonSlip = 0.0
self._compoundModel = None
self.__fashions = None
self.__filterRetrievers = []
self.__filterRetrieverGameObjects = []
self._vehicleStickers = None
self._vehicleInfo = {}
self.__vID = 0
self.__renderMode = None
self.__frameTimestamp = 0
self.__periodicTimerID = None
self.undamagedStateChildren = []
self.createComponent(VehicleAppearanceComponent, self)
self._loadingQueue = []
return
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.__fashion = None
self.crashedTracksController = None
self.__currentDamageState = VehicleDamageState()
self.__effectsPlayer = None
self.__engineMode = (0, 0)
self.__currTerrainMatKind = [-1] * _MATKIND_COUNT
self.__terrainEffectMaterialNames = [''] * _MATKIND_COUNT
self.__terrainMatKindLodDistance = _LOD_DISTANCE_TERRAIN_MATKIND_UPDATE
self.__chassisDecal = VehicleDecal(self)
self.__splodge = None
self.__vehicleStickers = None
self.onModelChanged = Event()
self.__leftTrackScroll = 0.0
self.__rightTrackScroll = 0.0
self.__fashions = None
self.__compoundModel = None
self.__boundEffects = None
self.__splineTracks = None
self.flyingInfoProvider = Vehicular.FlyingInfoProvider()
self.__trackScrollCtl = BigWorld.PyTrackScroll()
self.__trackScrollCtl.setFlyingInfo(
DataLinks.createBoolLink(self.flyingInfoProvider,
'isLeftSideFlying'),
DataLinks.createBoolLink(self.flyingInfoProvider,
'isRightSideFlying'))
self.__weaponEnergy = 0.0
self.__activated = False
self.__systemStarted = False
self.__outfit = None
self.__vID = 0
self.__isAlive = True
self.__isTurretDetached = False
self.__periodicTimerID = None
self.__wasDeactivated = False
self.__dirtUpdateTime = 0.0
self.__inSpeedTreeCollision = False
self.__isObserver = False
self.__chassisColisionMatrix = Math.WGAdaptiveMatrixProvider()
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 assembleVehicleAudition(isPlayer, appearance):
PLAYER_UPDATE_PERIOD = 0.1
NPC_UPDATE_PERIOD = 0.25
typeDescriptor = appearance.typeDescriptor
engineEventName = typeDescriptor.engine.sounds.getWWPlayerSound(isPlayer)
chassisEventName = typeDescriptor.chassis.sounds.getWWPlayerSound(isPlayer)
vehicleData = (typeDescriptor.physics['enginePower'] /
component_constants.HP_TO_WATTS,
typeDescriptor.physics['weight'],
typeDescriptor.physics['rotationSpeedLimit'])
vehicleAudition = Vehicular.VehicleAudition(appearance.id, isPlayer,
vehicleData, engineEventName,
chassisEventName)
vehicleAudition.setEffectMaterialsInfo(
lambda: appearance.terrainEffectMaterialNames)
vehicleAudition.setSpeedInfo(lambda: appearance.filter.angularSpeed,
lambda: appearance.filter.strafeSpeed)
vehicleAudition.setTrackScrollInfo(
lambda: appearance.leftTrackScroll,
lambda: appearance.rightTrackScroll,
lambda: appearance.customEffectManager.getParameter('deltaL'),
lambda: appearance.customEffectManager.getParameter('deltaR'))
vehicleAudition.setIsFlyingInfo(
DataLinks.createBoolLink(appearance.flyingInfoProvider, 'isFlying'))
if typeDescriptor.type.siegeModeParams is not None:
soundStateChange = typeDescriptor.type.siegeModeParams[
'soundStateChange']
vehicleAudition.setSiegeSoundEvents(
soundStateChange.on if soundStateChange.on is not None else '',
soundStateChange.off if soundStateChange.off is not None else '')
vehicleAudition.setDetailedEngineState(appearance.detailedEngineState)
vehicleAudition.setUpdatePeriod(
PLAYER_UPDATE_PERIOD if isPlayer else NPC_UPDATE_PERIOD)
appearance.engineAudition = vehicleAudition
return
def assembleDrivetrain(appearance, isPlayerVehicle):
vehicleFilter = appearance.filter
typeDescriptor = appearance.typeDescriptor
PLAYER_UPDATE_PERIOD = 0.1
NPC_UPDATE_PERIOD = 0.25
engineState = appearance.createComponent(Vehicular.DetailedEngineState)
engineState.vehicleSpeedLink = DataLinks.createFloatLink(vehicleFilter, 'averageSpeed')
engineState.rotationSpeedLink = DataLinks.createFloatLink(vehicleFilter, 'averageRotationSpeed')
engineState.vehicleMatrixLink = appearance.compoundModel.root
speed_limits_0 = typeDescriptor.physics['speedLimits'][0]
speed_limits_1 = typeDescriptor.physics['speedLimits'][1]
rpm_min = typeDescriptor.engine.rpm_min
rpm_max = typeDescriptor.engine.rpm_max
rotation_speed_limit = typeDescriptor.physics['rotationSpeedLimit']
max_climb_angle = math.acos(typeDescriptor.physics['minPlaneNormalY'])
engineState.setVehicleParams(speed_limits_0, speed_limits_1, rotation_speed_limit, max_climb_angle, rpm_min, rpm_max, isPlayerVehicle)
wheeledVehicle = False
if typeDescriptor.chassis.generalWheelsAnimatorConfig is not None:
wheeledVehicle = typeDescriptor.chassis.generalWheelsAnimatorConfig.isWheeledVehicle()
if wheeledVehicle and isPlayerVehicle:
gearShiftMap = (((1e-05, rpm_min * 1.2, rpm_max * 0.98),
(0.15 * speed_limits_0, rpm_min * 1.7, rpm_max * 0.98),
(0.5 * speed_limits_0, rpm_min * 2.2, rpm_max * 0.98),
(0.7 * speed_limits_0, rpm_max * 0.7, rpm_max * 0.9)), ((0.01, rpm_min * 1.2, rpm_max * 0.98),))
gearbox = appearance.createComponent(Vehicular.GearBox, speed_limits_0, speed_limits_1, rpm_min, rpm_max, gearShiftMap)
gearbox.engineModeLink = DataLinks.createIntLink(engineState, 'mode')
gearbox.vehicleSpeedLink = DataLinks.createFloatLink(vehicleFilter, 'averageSpeed')
gearbox.flyingLink = DataLinks.createBoolLink(appearance.flyingInfoProvider, 'isFlying')
else:
gearbox = None
if isPlayerVehicle:
if gearbox is not None:
engineState.physicRPMLink = lambda : gearbox.rpm
engineState.physicGearLink = lambda : gearbox.gear
elif not IS_EDITOR:
p = BigWorld.player()
engineState.physicRPMLink = lambda : WoT.unpackAuxVehiclePhysicsData(p.ownVehicleAuxPhysicsData)[5]
engineState.physicGearLink = lambda : BigWorld.player().ownVehicleGear
else:
engineState.physicRPMLink = None
engineState.physicGearLink = None
engineState.updatePeriod = PLAYER_UPDATE_PERIOD if isPlayerVehicle else NPC_UPDATE_PERIOD
return (engineState, gearbox)
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 _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
def assembleVehicleAudition(isPlayer, appearance):
PLAYER_UPDATE_PERIOD = 0.1
NPC_UPDATE_PERIOD = 0.25
typeDescriptor = appearance.typeDescriptor
engineEventName = typeDescriptor.engine.sounds.getEvents()
chassisEventName = typeDescriptor.chassis.sounds.getEvents()
wheeledVehicle = False
if typeDescriptor.chassis.generalWheelsAnimatorConfig is not None:
wheeledVehicle = typeDescriptor.chassis.generalWheelsAnimatorConfig.isWheeledVehicle()
if wheeledVehicle:
vehicleData = (typeDescriptor.physics['enginePower'] / component_constants.HP_TO_WATTS,
typeDescriptor.physics['weight'],
typeDescriptor.physics['rotationSpeedLimit'],
engineEventName,
chassisEventName,
('wheel_vehicle_wheel_repaired', 'wheel_vehicle_wheel_metal_repaired'),
('wheel_vehicle_wheel_damaged', 'wheel_vehicle_wheel_metal_damaged'),
'RTPC_ext_client_rpm_rel',
'RTPC_ext_client_rpm_abs')
else:
vehicleData = (typeDescriptor.physics['enginePower'] / component_constants.HP_TO_WATTS,
typeDescriptor.physics['weight'],
typeDescriptor.physics['rotationSpeedLimit'],
engineEventName,
chassisEventName,
('repair_treads',),
('brakedown_treads',),
'',
'')
vehicleAudition = appearance.createComponent(Vehicular.VehicleAudition, appearance.id, isPlayer, vehicleData)
vehicleAudition.setEffectMaterialsInfo(lambda : appearance.terrainEffectMaterialNames)
vehicleAudition.setSpeedInfo(lambda : appearance.filter.angularSpeed, lambda : appearance.filter.strafeSpeed)
vehicleAudition.setTracksInfo(lambda : appearance.transmissionScroll, lambda : appearance.transmissionSlip, lambda : appearance.getWheelsSteeringMax(), DataLinks.createBoolLink(appearance.flyingInfoProvider, 'isFlying'))
if typeDescriptor.type.siegeModeParams is not None:
soundStateChange = typeDescriptor.type.siegeModeParams['soundStateChange']
vehicleAudition.setSiegeSoundEvents(soundStateChange.isEngine, soundStateChange.on if isPlayer else soundStateChange.npcOn, soundStateChange.off if isPlayer else soundStateChange.npcOff)
vehicleAudition.setDetailedEngineState(appearance.detailedEngineState)
vehicleAudition.setUpdatePeriod(PLAYER_UPDATE_PERIOD if isPlayer else NPC_UPDATE_PERIOD)
appearance.engineAudition = vehicleAudition
return
