def __playEffect(self, kind, *modifs):
self.__stopEffects()
if kind == 'empty' or self.__vehicle is None:
return
else:
enableDecal = True
if kind in ('explosion', 'destruction') and self.isFlying:
enableDecal = False
if self.isUnderwater:
if kind not in ('submersionDeath', ):
return
effects = self.typeDescriptor.type.effects[kind]
if not effects:
return
vehicle = self.__vehicle
effects = random.choice(effects)
self.__effectsPlayer = EffectsListPlayer(
effects[1],
effects[0],
showShockWave=vehicle.isPlayerVehicle,
showFlashBang=vehicle.isPlayerVehicle,
isPlayer=vehicle.isPlayerVehicle,
showDecal=enableDecal,
start=vehicle.position + Math.Vector3(0.0, 1.0, 0.0),
end=vehicle.position + Math.Vector3(0.0, -1.0, 0.0),
entity_id=vehicle.id)
self.__effectsPlayer.play(self.__compoundModel, *modifs)
return
def attach(self):
if self.__player is None:
self.__player = EffectsListPlayer(self.__timeLine.effectsList,
self.__timeLine.keyPoints,
node=self.__node.node)
self.__player.play(self.__model)
return
def addNew(self, matProv, effectsList, keyPoints, **args):
desc = EffectsListPlayer(effectsList,
keyPoints,
position=(self.__nodeName, matProv),
**args)
desc.play(self.__model, None, partial(self._effects.remove, desc))
self._effects.append(desc)
def __createEffectPlayer(self, effectName):
effect = self.__customizableObjectsMgr.getEffect(effectName)
if effect is None:
return
else:
effectPlayer = EffectsListPlayer(effect.effectsList,
effect.keyPoints)
return effectPlayer
def __playPullEffect(self, effectMaterialIdx):
self.__stopPullEffects()
stages, effectsList, _ = self.__detachmentEffectsDesc['pull'][
effectMaterialIdx]
self.__pullEffectListPlayer = EffectsListPlayer(effectsList, stages)
self.__pullEffectListPlayer.play(self.__turretModel,
SpecialKeyPointNames.START)
self.__pullEffectListPlayer.effectMaterialIdx = effectMaterialIdx
def _start(self, data, burstCount):
vehicle = data['entity']
gunDescr = vehicle.typeDescriptor.gun
stages, effects, _ = gunDescr['effects']
data['entity_id'] = vehicle.id
data['_effectsListPlayer'] = EffectsListPlayer(effects, stages, **data)
data['_burst'] = (burstCount, gunDescr['burst'][1])
data['_gunModel'] = vehicle.appearance.compoundModel
self.__doShot(data)
def addNewToNode(self, node, matProv, effectsList, keyPoints, waitForKeyOff=False, **args):
if not node and matProv is None:
position = None
else:
position = (node, matProv)
desc = EffectsListPlayer(effectsList, keyPoints, position=position, **args)
desc.play(self.__model, None, partial(self._effects.remove, desc), waitForKeyOff)
self._effects.append(desc)
return desc
def __playEffect(self, model, effectName):
effectsCache = self.customizableObjectsMgr.effectsCache
if effectName in effectsCache:
effect = effectsCache[effectName]
effectPlayer = EffectsListPlayer(effect.effectsList,
effect.keyPoints)
effectPlayer.play(model)
else:
effectPlayer = MapActivities.startActivity(effectName)
return effectPlayer
def playEffect(self):
if self.__effectsPlayer is not None:
return
elif self.__model is None:
return
else:
if self.__effectsTimeLine is not None:
self.__effectsPlayer = EffectsListPlayer(self.__effectsTimeLine.effectsList, self.__effectsTimeLine.keyPoints)
self.__effectsPlayer.play(self.__model)
return
def __playEffects(self, model, regularEffectName, hangingEffectName):
hangingEffectPlayer = None
if regularEffectName in self.__effectsCache:
regularEffect = self.__effectsCache[regularEffectName]
regularEffectPlayer = EffectsListPlayer(regularEffect.effectsList,
regularEffect.keyPoints)
regularEffectPlayer.play(model)
else:
regularEffectPlayer = MapActivities.startActivity(
regularEffectName)
if self.customizableObjectsMgr.state:
if hangingEffectName in self.__effectsCache:
hangingEffect = self.__effectsCache[hangingEffectName]
hangingEffectPlayer = EffectsListPlayer(
hangingEffect.effectsList, hangingEffect.keyPoints)
hangingEffectPlayer.play(model)
else:
hangingEffectPlayer = MapActivities.startActivity(
hangingEffectName)
return (regularEffectPlayer, hangingEffectPlayer)
def _start(self, data, burstCount):
if not _isAllowedToStart():
return
vehicle = data['entity']
gunDescr = vehicle.typeDescriptor.gun
stages, effects, _ = gunDescr['effects']
data['_effectsListPlayer'] = EffectsListPlayer(effects, stages)
data['_burst'] = (burstCount, gunDescr['burst'][1])
data['_gunModel'] = vehicle.appearance.modelsDesc['gun']['model']
if vehicle.isPlayer:
BigWorld.addAlwaysUpdateModel(data['_gunModel'])
self.__doShot(data)
def _start(self, data, burstCount):
vehicle = data['entity']
gunDescr = vehicle.typeDescriptor.gun
stages, effects, _ = gunDescr['effects']
data['modelMap'] = {}
for i, j in vehicle.appearance.modelsDesc.iteritems():
data['modelMap'][i] = vehicle.appearance.modelsDesc[i]['model']
data['entity_id'] = vehicle.id
data['_effectsListPlayer'] = EffectsListPlayer(effects, stages, **data)
data['_burst'] = (burstCount, gunDescr['burst'][1])
data['_gunModel'] = vehicle.appearance.modelsDesc['gun']['model']
self.__doShot(data)
def __playPullEffect(self, effectMaterialIdx):
self.__stopPullEffects()
result = self.__detachmentEffectsDesc['pull'].get(
effectMaterialIdx, None)
if result is None:
return
else:
stages, effectsList, _ = result
self.__pullEffectListPlayer = EffectsListPlayer(
effectsList, stages)
self.__pullEffectListPlayer.play(self.__turretModel,
SpecialKeyPointNames.START)
self.__pullEffectListPlayer.effectMaterialIdx = effectMaterialIdx
return
def addNew(self, position, effectsList, keyPoints, callbackOnStop, **args):
model = helpers.newFakeModel()
model.position = position
BigWorld.player().addModel(model)
direction = args.get('dir', None)
if direction is not None:
model.rotate(direction.yaw, (0.0, 1.0, 0.0))
self.__incrementalEffectID += 1
effectID = self.__incrementalEffectID
desc = dict()
desc['model'] = model
desc['effectsPlayer'] = EffectsListPlayer(effectsList, keyPoints, **args)
desc['effectsPlayer'].play(model, None, partial(self.__callbackBeforeDestroy, effectID, callbackOnStop), args.get('waitForKeyOff', False))
self._models[effectID] = desc
return effectID
def __readHeroEffects(self):
if not self.effectsXmlPath:
return
else:
rootSection = ResMgr.openSection(self.effectsXmlPath)
if rootSection is None:
return
effectsSection = rootSection['effects']
if effectsSection is None:
return
for effectValues in effectsSection.values():
name = effectValues.name
effect = effectsFromSection(effectValues)
player = EffectsListPlayer(effect.effectsList,
effect.keyPoints)
self.__effects[name] = player
return
def _start(self, data, args):
burstCount, gunIndex = args
if burstCount != self._SHOT_SINGLE:
data['_gunIndex'] = range(0, burstCount)
else:
data['_gunIndex'] = [gunIndex]
vehicle = data['entity']
gunDescr = vehicle.typeDescriptor.gun
data['entity_id'] = vehicle.id
effectPlayers = {}
for gunIndex in data['_gunIndex']:
stages, effects, _ = gunDescr.effects[gunIndex]
effectPlayers[gunIndex] = EffectsListPlayer(effects, stages, **data)
data['_effectsListPlayers'] = effectPlayers
data['_burst'] = (burstCount, gunDescr.burst[1])
data['_gunModel'] = vehicle.appearance.compoundModel
self.__doShot(data)
def __playEffect(self, effectName, model):
if self.__effectsPlayer is not None or None in (model, effectName):
return
else:
effectsSection = destructible_entities.g_destructibleEntitiesCache.getDestroyEffectList(
effectName)
if effectsSection is None:
return
effects = effectsFromSection(effectsSection)
if effects is None:
return
fakeModel = helpers.newFakeModel()
BigWorld.player().addModel(fakeModel)
tmpMatrix = Math.Matrix(self.__visualModel.matrix)
fakeModel.position = tmpMatrix.translation
self.__effectsPlayer = EffectsListPlayer(effects.effectsList,
effects.keyPoints)
self.__effectsPlayer.play(fakeModel, None)
return
def _start(self, data, args):
data['_isStarted'] = False
vehicle = data['entity']
isUnderwater = vehicle.appearance.isUnderwater
data['wasUnderwater'] = isUnderwater
if not isUnderwater:
stages, effects, _ = random.choice(
vehicle.typeDescriptor.type.effects['flaming'])
data['modelMap'] = {}
for i, j in vehicle.appearance.modelsDesc.iteritems():
data['modelMap'][i] = vehicle.appearance.modelsDesc[i]['model']
data['entity_id'] = vehicle.id
effectListPlayer = EffectsListPlayer(effects, stages, **data)
data['_effectsPlayer'] = effectListPlayer
effectListPlayer.play(
vehicle.appearance.modelsDesc['hull']['model'], None, None,
True)
data['_isStarted'] = True
vehicle.appearance.switchFireVibrations(True)
def checkUnderwater(self, data, vehicle, isVehicleUnderwater):
wasUnderwater = data.get('wasUnderwater', False)
if isVehicleUnderwater and not wasUnderwater:
if '_effectsPlayer' in data:
effectsListPlayer = data['_effectsPlayer']
effectsListPlayer.stop()
del data['_effectsPlayer']
if not isVehicleUnderwater and wasUnderwater:
stages, effects, _ = random.choice(
vehicle.typeDescriptor.type.effects['flaming'])
data['modelMap'] = {}
for i, j in vehicle.appearance.modelsDesc.iteritems():
data['modelMap'][i] = vehicle.appearance.modelsDesc[i]['model']
data['entity_id'] = vehicle.id
effectListPlayer = EffectsListPlayer(effects, stages, **data)
data['_effectsPlayer'] = effectListPlayer
effectListPlayer.play(
vehicle.appearance.modelsDesc['hull']['model'], None, None,
True)
data['wasUnderwater'] = isVehicleUnderwater
def addNew(self, position, effectsList, stages, callbackOnStop, **args):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isTimeWarpInProgress:
return -1
else:
model = BigWorld.player().newFakeModel()
model.position = position
BigWorld.addModel(model)
BigWorld.addAlwaysUpdateModel(model)
dir = args.get('dir', None)
if dir is not None:
model.rotate(dir.yaw, (0.0, 1.0, 0.0))
self.__incrementalEffectID += 1
effectID = self.__incrementalEffectID
desc = dict()
desc['model'] = model
desc['effectsPlayer'] = EffectsListPlayer(effectsList, stages,
**args)
desc['effectsPlayer'].play(
model, None,
partial(self.__callbackBeforeDestroy, effectID,
callbackOnStop))
self._models[effectID] = desc
return effectID
def __playStateEffect(self, startKeyPoint=SpecialKeyPointNames.START):
self.__stopStateEffects()
effectName = _TurretDetachmentEffects.__EFFECT_NAMES[self.__state]
stages, effectsList, _ = self.__detachmentEffectsDesc[effectName]
self.__stateEffectListPlayer = EffectsListPlayer(effectsList, stages)
self.__stateEffectListPlayer.play(self.__turretModel, startKeyPoint)
