def loadArena(self):
self.__interactiveMix.createArena()
self.__voice = VoiceoversSoundObject()
self.__hits = HitSFXFactory()
self.__explosions = ExplosionSFXFactory()
self.music.playArena()
self.__prevTarget = None
self.__winner = False
self.__draw = False
self.__prevTarget = None
self.__burning = {}
postGlobalEvent(GLOBAL_EVENTS.LOAD_ARENA)
GameEnvironment.getClientArena(
).onGameResultChanged += self.__onGameResultChanged
SoundUpdateManager.instance().start()
return
def __getFightPhase(self, flag=FLAG.NONE):
if self.__currentSoundPhase in (
SOUND_PHASES.RESULT_SCREEN,
SOUND_PHASES.SCREEN) or self.__currentSoundPhase in (
SOUND_PHASES.SPECTATOR,
SOUND_PHASES.NOSEDIVING) and not flag == FLAG.RESPAWN:
return
phase = SOUND_PHASES.PILOTING
player = BigWorld.player()
visibleAvatars = player.visibleAvatars.values()
if flag == FLAG.LEAVE_WORLD:
enemiesCounter = 0
for avatar in visibleAvatars:
arena = GameEnvironment.getClientArena()
isTeamate = arena.avatarInfos.get(player.id).get(
'teamIndex',
-1) == arena.avatarInfos.get(avatar.id).get('teamIndex', -1)
if not isTeamate and not EntityStates.inState(
avatar, EntityStates.DESTROYED):
if not flag == FLAG.LEAVE_WORLD or enemiesCounter:
phase = SOUND_PHASES.DOGFIGHT
break
else:
enemiesCounter += 1
return phase
def _createControllers(self):
controllersData = GameEnvironment.getClientArena(
).createTeamObjectControllers(self.id, self._settings, self,
self.partTypes, self.partStates)
modelManipulator = controllersData['modelManipulator']
self._registerController('modelManipulator', modelManipulator)
self.model = modelManipulator.getRootModel()
self.model.delMotor(self.model.motors[0])
self.model.addMotor(BigWorld.Servo(self.resMatrix))
modelManipulator.setMatrixProvider(self.resMatrix)
turretsLogic = controllersData.get('turretsLogic', None)
if turretsLogic:
turretsLogic.setOwner(self)
self._registerController('turretsLogic', turretsLogic)
self.ePartStateChanged += turretsLogic.onPartStateChanged
if self.scenarioName != '':
if not self.scenarioName.endswith(
'.xml') and not self.scenarioName.endswith('.plan'):
scenarioData = db.DBLogic.g_instance.getScenario(
self.scenarioName)
if scenarioData:
scenarioController = TeamObjectScenarioController(
self, scenarioData)
self._registerController('scenarioController',
scenarioController)
else:
LOG_ERROR("Can't find scenario", self.scenarioName)
soundController = controllersData['soundController']
self._registerController('soundController', soundController)
return
def onPlayerLeaveWorld(self):
gm = extractGameMode(BigWorld.player().gameMode)
self.unloadArena()
BigWorld.player().eUpdateSpectator -= self.__onSpectator
gameMode = GameEnvironment.getClientArena().gameMode
gameMode.unsubscribe(self.__gameModeEventDispatcher)
self.__gameModeEventDispatcher.finish()
self.__gameModeEventDispatcher = None
return
def __clearBattleEvents(self):
player = BigWorld.player()
arena = GameEnvironment.getClientArena()
player.onStateChanged -= self.__onPlayerStateChanged
player.eUpdateSpectator -= self.__onSpectator
player.eArenaLoaded -= self.__onArenaLoaded
player.eRespawn -= self.__onPlayerRespawn
arena.onAvatarEnterWorld -= self.__onAvatarEnterWorld
arena.onAvatarLeaveWorld -= self.__onAvatarLeaveWorld
def createTurret(self):
arena = GameEnvironment.getClientArena()
for obj in arena.allObjectsData.items():
val = obj[1]
if 'turretsLogic' not in val or 'soundController' not in val:
continue
if not hasattr(val['soundController'], 'soundObjects'):
continue
for so in val['soundController'].soundObjects.values():
so.factory.createTurret(obj[0], so, val)
def onPlayerEnterWorld(self, *args, **kwargs):
"""Event handler for PlayerAvatar.eEnterWorldEvent
"""
gameMode = GameEnvironment.getClientArena().gameMode
if gameMode.isReady:
self.onGameModeReady()
else:
gameMode.eGameModeReady += self.onGameModeReady
self.__gameModeEventDispatcher = SoundEventDispatcher(gameMode)
gameMode.subscribe(self.__gameModeEventDispatcher)
self.camera.onPlayerEnterWorld()
def __showTextMessage(self,
senderID,
msgType,
messageStringID,
targetID,
message,
isHistory,
leaderType=-1,
isHTML=False):
messageT = ChatMessageVO()
messageT.msgType = msgType
messageT.senderID = senderID
messageT.message = message
messageT.isHistory = isHistory
messageT.leaderType = leaderType
owner = BigWorld.player()
clientArena = GameEnvironment.getClientArena()
if owner and clientArena:
avatarInfo = clientArena.getAvatarInfo(senderID)
if avatarInfo:
messageT.authorType = avatarInfo['settings'].airplane.planeType
messageT.authorName = avatarInfo['playerName']
messageT.vechicleName = localizeAirplane(
avatarInfo['settings'].airplane.name)
if avatarInfo['classID'] == EntitySupportedClasses.AvatarBot:
messageT.authorName = messageT.authorName.replace(
'>', '>').replace('<', '<')
messageT.authorClanAbbrev = avatarInfo['clanAbbrev']
if avatarInfo['teamIndex'] == BigWorld.player().teamIndex:
squadType = SQUAD_TYPES().getSquadType(
SQUAD_TYPES().getSquadIDbyAvatarID(senderID), senderID)
if squadType == SQUAD_TYPES.OWN:
messageT.teamType = TEAM_TYPE.BATTLE_SQUAD
else:
messageT.teamType = TEAM_TYPE.BATTLE_ALLY
else:
messageT.teamType = TEAM_TYPE.BATTLE_OPPONENT
else:
LOG_DEBUG('showTextMessage - avatarInfo is None', senderID,
msgType, messageStringID, targetID, message,
isHistory, leaderType)
messageT.isOwner = messageT.senderID == owner.id
if messageT.isOwner:
messageT.authorName = localizeHUD('HUD_YOU_MESSAGE')
messageT.authorClanAbbrev = ''
if messageT.message and not isHTML:
messageT.message = messageT.message.replace('>',
'>').replace(
'<', '<')
if messageT.senderID == self.__lastMessage.senderID and messageT.msgType == self.__lastMessage.msgType and messageT.message == self.__lastMessage.message and messageT.time - self.__lastMessage.time < MESSAGE_SAME_COOLDOWN:
return
self.__addChatMessage(messageT)
self.__lastMessage = messageT
def getLocalizedMessage(self, messageStringID, targetID=0):
"""
@param : int messageStringID, int targetID
@return: localization text
"""
if messageStringID not in self.__localize:
return 'ERROR LOCALIZE MESSAGE'
elif targetID != 0 and messageStringID in [
ChatMessagesStringID.JOIN_ME, ChatMessagesStringID.ENEMY_MY_AIM
]:
objectType = GameEnvironment.getClientArena().getTeamObjectType(
targetID)
if objectType is not None and objectType in OBJECTS_INFO:
objectName = localizeHUD(OBJECTS_INFO[objectType]['LOC_ID'])
else:
objectName = GameEnvironment.getClientArena().getObjectName(
targetID)
return localizeHUD(
self.__localize[messageStringID]).format(player=objectName)
else:
return localizeHUD(self.__localize[messageStringID])
return
def refreshClanEmblem(self):
if self.__surfaceTextures is not None:
if not consts.IS_EDITOR and clientConsts.ENABLE_PLANE_CLAN_EMBLEM:
import BWPersonality
env = GameEnvironment.getClientArena()
allowBGLoading = False if env and env.isLoaded() else True
if env:
avatarInfo = env.getAvatarInfo(self.__context.entityId)
clanDBID = avatarInfo.get('clanDBID')
if clanDBID and int(clanDBID) > 0:
ClanEmblemsCache.g_clanEmblemsCache.get(clanDBID, self.__updateClanEmblemClbk, not allowBGLoading)
elif int(BWPersonality.g_initPlayerInfo.clanDBID) > 0:
ClanEmblemsCache.g_clanEmblemsCache.get(BWPersonality.g_initPlayerInfo.clanDBID, self.__updateClanEmblemClbk, not allowBGLoading)
return
def setUsersChatStatus(self, usersList):
playersList = []
clientArena = GameEnvironment.getClientArena()
for userStatus in usersList:
playerID = clientArena.getAvatarIdByDBId(int(userStatus[0]))
if playerID is not None:
playersList.append((playerID, userStatus[1]))
else:
LOG_ERROR(
'setUsersChatStatus: can not get playerID by dbid(%s)' %
userStatus[0])
self.__setPlayersChatStatus(playersList)
return
def createAvatar(self, avatar, so):
if so.wwiseGameObject:
return
shootEvent = TurretSound.getShootEventName(False, False, False,
so.soundSet)
arena = GameEnvironment.getClientArena()
avatarInfo = arena.avatarInfos.get(avatar.id, {})
turrets = avatarInfo.get('turretsLogic')
if turrets and shootEvent:
so.wwiseGameObject = TurretSound(avatar.id,
so.context.cidProxy.handle,
so.node.id, so.weaponID,
shootEvent, False, True)
turrets.linkSound(so.turretID, so.wwiseGameObject)
def createAvatar(self, avatar, so):
if so.wwiseGameObject:
return
shootEvent = WeaponSound.getShootEventName(False, False, False,
so.soundSet)
if shootEvent:
so.wwiseGameObject = WeaponSound(avatar.id,
so.context.cidProxy.handle,
so.node.id, so.weaponID,
shootEvent)
arena = GameEnvironment.getClientArena()
avatarInfo = arena.avatarInfos.get(avatar.id, {})
weapons = avatarInfo.get('weapons')
weapons.linkSound(so.weaponID, so.wwiseGameObject)
def __init__(self):
WwiseGameObject.__init__(self, 'Voiceover')
self.__soundBanksManager = SoundBanksManager.instance()
self.__playNow = None
self.__isLock = False
self.__queue = VoiceoversQueue(VOICEOVERS_QUEUE_SIZE - 1)
self.__clientArena = GameEnvironment.getClientArena()
self.__gameModeIndex = self.__clientArena.gameModeEnum - GAME_MODE.AREA_CONQUEST
self.__player = BigWorld.player()
self.__initVoiceovers()
self.load()
self.__initAdditionalDataForEvents()
self.__registerEvents()
self.__ignoreWhenLock = [VOICE.TEAM_WIN, VOICE.TEAM_LOSE]
return
def getSquadType(squadNumber, avatarID):
if not squadNumber:
return SQUAD_TYPES.WITHOUT_SQUAD
owner = BigWorld.player()
if avatarID == owner.id:
return SQUAD_TYPES.OWN
clientArena = GameEnvironment.getClientArena()
ownerInfo = clientArena.getAvatarInfo(owner.id)
avatarInfo = clientArena.getAvatarInfo(avatarID)
if ownerInfo is not None and avatarInfo is not None:
if owner.teamIndex == avatarInfo['teamIndex'] and ownerInfo['squadID'] == squadNumber:
return SQUAD_TYPES.OWN
return SQUAD_TYPES.OTHER
else:
return
def createAvatar(self, avatar, so):
soundController = avatar.controllers.get('soundController', None)
if soundController and SOUND_OBJECT_TYPES.WIND not in soundController.soundModeHandlers:
arena = GameEnvironment.getClientArena()
avatarInfo = arena.avatarInfos.get(avatar.id, {})
playerTeam = arena.avatarInfos.get(BigWorld.player().id).get(
'teamIndex', None)
avatarTeam = avatarInfo.get('teamIndex', None)
isPlayerTeamate = playerTeam is not None and playerTeam == avatarTeam
if isPlayerTeamate:
soundController.soundModeHandlers[
SOUND_OBJECT_TYPES.WIND] = SoundModeHandler(
avatar.id, so, self.__soundStrategies,
SOUND_MODES.AVATAR)
return
def __init__(self):
self._eventManager = EventManager()
self.eInitConsumables = Event(self._eventManager)
self.eUpdateConsumables = Event(self._eventManager)
self.eUpdateConsumableStatus = Event(self._eventManager)
self.__update1secCallBack = -1
self._playerAvatar = GameEnvironment.g_instance.playerAvatarProxy
self._clientArena = GameEnvironment.getClientArena()
self._modulesDict = {}
self._isFire = False
from db.DBLogic import g_instance as db
self._db = db
self._clientArena.onNewAvatarsInfo += self._onSetupManager
self._isArenaReady = False
if self._clientArena.isAllServerDataReceived():
self._onSetupManager(None)
return
def __init__(self, gameMode):
self._gameMode = gameMode
self._clientArena = GameEnvironment.getClientArena()
self._eManager = EventManager()
self.eUpdateLastPlayer = Event(self._eManager)
self.__disableRespawns = False
self.__lastPlayerReported = False
self.__lastEnemyReported = False
self.__loadingBarrier = ConditionsBarrier(LOADING_CONDITION.ALL, self.__onLoadAllData)
if self._gameMode.isReady:
self.__onGameModeReady()
else:
self._gameMode.eGameModeReady += self.__onGameModeReady
if self._clientArena.isAllServerDataReceived():
self.__onAvatarInfo(None)
else:
self._clientArena.onNewAvatarsInfo += self.__onAvatarInfo
return
def getTerrainPointAndMaterial(spaceID, position):
waterLevel = GameEnvironment.getClientArena().getWaterLevel()
res = Math.Vector3(position)
materialName = None
heightCollide = BigWorld.hm_collideSimple(
spaceID, position + Math.Vector3(0, 1500, 0),
position - Math.Vector3(0, 1500, 0))
if heightCollide is not None:
try:
materialName = db.DBLogic.g_instance.getMaterialName(
heightCollide[1])
except:
pass
res = heightCollide[0]
if res.y < waterLevel:
res.y = waterLevel
return (res, materialName)
def __onGameResultChanged(self, gameResult, winState):
winResults = [
GAME_RESULT.SUPERIORITY_SUCCESS, GAME_RESULT.ELIMINATION,
GAME_RESULT.AREA_CONQUEST_SUCCESS, GAME_RESULT.CAPTURE_ALL_SECTORS,
GAME_RESULT.MAIN_TIME_RUNNING_OUT,
GAME_RESULT.DYNAMIC_TIME_RUNNING_OUT, GAME_RESULT.ATTRITION_SUCCESS
]
self.__winner = gameResult in winResults and BigWorld.player(
).teamIndex == winState
self.__draw = gameResult in [
GAME_RESULT.DRAW_ELIMINATION,
GAME_RESULT.DRAW_ELIMINATION_NO_PLAYERS,
GAME_RESULT.DRAW_SUPERIORITY, GAME_RESULT.DRAW_TIME_IS_RUNNING_OUT,
GAME_RESULT.DRAW_AREA_CONQUEST,
GAME_RESULT.DYNAMIC_TIME_RUNNING_OUT, GAME_RESULT.ATTRITION_DRAW,
GAME_RESULT.ATTRITION_TIME_RUNNING_OUT
]
battleType = GameEnvironment.getClientArena().battleType
if battleType == ARENA_TYPE.TRAINING:
self.onBattleEnd(False)
def _checkLoadingTime(self):
arena = GameEnvironment.getClientArena()
if arena is None:
return
else:
vehiclesLoadStatusInfo = arena.vehiclesLoadStatus()
vehiclesLoadStatus = 1.0
if vehiclesLoadStatusInfo[1] > 0:
vehiclesLoadStatus = float(
vehiclesLoadStatusInfo[0]) / vehiclesLoadStatusInfo[1]
spaceLoadStatus = BigWorld.spaceLoadStatus()
loadLevel = int(50 * (spaceLoadStatus + vehiclesLoadStatus))
if loadLevel >= 100.0:
self._playerAvatar.onArenaLoaded()
self._playerCallback = None
else:
GameEnvironment.g_instance.eLoadingProgress(loadLevel)
self._playerCallback = BigWorld.callback(
0.5, self._checkLoadingTime)
return
def getDistancesForPlayer(playerAvatar, battleMode):
global VERY_FAR_DISTANCE_BY_LEVEL
global AIM_DISTANCE_BY_PLANE_TYPE_BY_LEVEL
clientArena = GameEnvironment.getClientArena()
avatarInfo = clientArena.getAvatarInfo(playerAvatar.id)
if avatarInfo is None:
return
else:
settings = avatarInfo['settings']
effectiveShootingDistance = _getGunnerShootingDistance(
playerAvatar
) if battleMode == BATTLE_MODE.GUNNER_MODE else _getMainArmamentShootingDistance(
playerAvatar)
planeLevel = settings.airplane.level
planeType = settings.airplane.planeType
aimDistance = AIM_DISTANCE_BY_PLANE_TYPE_BY_LEVEL[planeType][
planeLevel]
veryFarDistance = VERY_FAR_DISTANCE_BY_LEVEL[planeLevel]
return (('Shooting', effectiveShootingDistance),
('Aiming', aimDistance), ('Far', veryFarDistance))
def showBattleMessageReactionResult(self, battleMessageType, isPositive,
senderID, callerID, targetID):
ownerID = BigWorld.player().id
doShowChatMessage = ownerID == callerID
reactionType = BattleMessageReactionHelper.BATTLE_MESSAGE_TYPE_RESULT_MAP_POSITIVE.get(
battleMessageType,
None) if isPositive else BATTLE_MESSAGE_TYPE.FAILURE
if not doShowChatMessage:
return
else:
arena = GameEnvironment.getClientArena()
senderName, callerName, targetName = arena.getObjectName(
senderID), arena.getObjectName(callerID), arena.getObjectName(
targetID)
textMessage = MessagesID().getLocalizedMessage(
reactionType, targetID
) if BattleMessageReactionHelper.USE_STANDARD_MESSAGE_TEXT else BattleMessageReactionHelper.LocalizeBattleMessageReaction(
battleMessageType, isPositive, senderName, callerName,
targetName)
if BattleMessageReactionHelper.USE_COLORS:
htmlText = textMessage.replace('>', '>')
htmlText = htmlText.replace('<', '<')
isColorBlind = Settings.g_instance.getGameUI(
)['alternativeColorMode']
if isColorBlind:
colorCode = BattleMessageReactionHelper.POSITIVE_REACTION_COLOR_ALT if isPositive else BattleMessageReactionHelper.NEGATIVE_REACTION_COLOR_ALT
else:
colorCode = BattleMessageReactionHelper.POSITIVE_REACTION_COLOR if isPositive else BattleMessageReactionHelper.NEGATIVE_REACTION_COLOR
htmlText = '<font color="{}">{}</font>'.format(
colorCode, htmlText)
self.__showTextMessage(senderID,
MESSAGE_TYPE.BATTLE_ALLY,
0,
callerID,
htmlText,
False,
isHTML=True)
return
self.__showTextMessage(senderID, MESSAGE_TYPE.BATTLE_ALLY, 0,
callerID, textMessage, False)
return
def updateTemporaryVisibleObjectData(self, objectUpdatableData,
objectClassID, objectTeamIndex,
modelID):
"""
add new object info or update it.
Used for objects which could not be visible because of Bigworld issue
@param objectUpdatableData:
@type objectUpdatableData: ["id", "position", "angle", "isVisible"]
@param objectClassID: EntitySupportedClasses const
@type objectClassID: int
@param objectTeamIndex: 0 or 1
@type objectTeamIndex: int
@param modelID: object ID to get it settings
@type modelID: int
"""
arenaData = GameEnvironment.getClientArena().arenaData
iD, positionPacked, yawPacked, alive = objectUpdatableData
position = unpackPositionFrom3DTuple(positionPacked,
arenaData['bounds'])
mapEntry = self.__list.get(iD, None)
if not mapEntry:
mapEntry = MapEntry(iD, objectClassID, objectTeamIndex, position,
alive, modelID)
self.__list[iD] = mapEntry
if BigWorld.entities.has_key(iD):
mapEntry.isClientInAOI = True
BigWorld.entities[iD].onMapEntryCreated(mapEntry)
else:
mapEntry.isAlive = alive
mapEntry.isClientInAOI = BigWorld.entities.has_key(iD)
if mapEntry.isAlive:
yaw = unpackAngleFromByte(yawPacked)
mapEntry.setPositionAndYaw(Math.Vector3(position), yaw)
if mapEntry.isObjectChanged:
self.__updateObjectVisibility(mapEntry)
mapEntry.resetMarksOfChanges()
return
def onReceiveMarkerMessage(self, senderID, posX, posZ, messageStringID,
isHistory):
if self.__arenaBounds is None:
arena = GameEnvironment.getClientArena()
self.__arenaBounds = self._makeBoundsObject(arena.getArenaBounds())
percentX = 100 * (posX - self.__arenaBounds.get('left')) / (
self.__arenaBounds.get('right') - self.__arenaBounds.get('left'))
percentY = 100 * (
1 - (posZ - self.__arenaBounds.get('top')) /
(self.__arenaBounds.get('bottom') - self.__arenaBounds.get('top')))
zoneSymbol = self.__zoneSymbols[self.getZoneIndex(percentY)]
zoneNumber = 1 + self.getZoneIndex(percentX)
message = localizeHUD(
self.MARKER_MESSAGES_LOC_IDS[messageStringID]).format(
grid_square=zoneSymbol + str(zoneNumber))
messageType = MESSAGE_TYPE.BATTLE_ALLY
if senderID != BigWorld.player().id:
squadType = SQUAD_TYPES().getSquadType(
SQUAD_TYPES().getSquadIDbyAvatarID(senderID), senderID)
if squadType == SQUAD_TYPES.OWN:
messageType = MESSAGE_TYPE.BATTLE_SQUAD
self.__showTextMessage(senderID, messageType, 0, 0, message, isHistory)
return
def buildHudFeatures(gameModel, features, stateManager):
import BigWorld
import GameEnvironment
import Settings
import audio
import db.DBLogic
import BattleReplay
import _airplanesConfigurations_db
features.provide(Feature.BIG_WORLD, BigWorld)
features.provide(Feature.UI_SOUND, audio.GameSound().ui)
features.provide(Feature.DB_LOGIC, db.DBLogic.g_instance)
gameEnvironment = GameEnvironment.g_instance
features.provide(Feature.GAME_ENVIRONMENT, gameEnvironment)
features.provide(Feature.INPUT, gameEnvironment.service(Feature.INPUT))
features.provide(Feature.CAMERA, gameEnvironment.service(Feature.CAMERA))
features.provide(Feature.GAME_PLAY_HINTS,
gameEnvironment.service(Feature.GAME_PLAY_HINTS))
features.provide(Feature.CLIENT_ARENA, GameEnvironment.getClientArena())
features.provide(Feature.PLAYER_AVATAR,
GameEnvironment.g_instance.playerAvatarProxy)
features.provide(Feature.REAL_PLAYER_AVATAR, BigWorld.player())
features.provide(Feature.TIMER_SERVICE,
GameEnvironment.g_instance.getTimer())
features.provide(Feature.CLIENT_ECONOMICS,
GameEnvironment.getClientEconomics())
features.provide(Feature.MEASUREMENT_SYSTEM, MeasurementSystem())
features.provide(Feature.PREPARED_BATTLE_DATA, preparedBattleData)
features.provide(Feature.PLANES_CONFIGURATIONS_DB,
_airplanesConfigurations_db)
features.provide(Feature.GAME_MODEL, gameModel)
features.provide(Feature.UI_SETTINGS, Settings.g_instance)
features.provide(Feature.STATE_MANAGER, stateManager)
features.provide(Feature.XMPP_CHAT, messenger.g_xmppChatHandler)
features.provide(Feature.BATTLE_REPLAY, BattleReplay.g_replay)
features.provide(Feature.BATTLE_HINTS,
GameEnvironment.getBattleHintMessenger())
features.provide(Feature.CONSUMABLES_MANAGER, ConsumableManager())
def getSquadIDbyAvatarID(avatarID):
avatarInfo = GameEnvironment.getClientArena().getAvatarInfo(avatarID)
if avatarInfo is not None and 'squadID' in avatarInfo:
return avatarInfo['squadID']
else:
return 0
def onLeaveWorld(self):
proxy = GameEnvironment.getClientArena().gameActionsManager
proxy.onManagerLeaveWorld(self)
self._eManager.clear()
self.logger.info('Left world, id = {0}'.format(self.id))
def onEnterWorld(self, prereqs):
proxy = GameEnvironment.getClientArena().gameActionsManager
proxy.onManagerEnterWorld(self)
self._processWavesUpdate()
self.logger.info('Entered world, id = {0}'.format(self.id))
def ballisticShot(actionData, environmentData):
def getStartPos(environmentData, modelManipulator):
objPos = environmentData.destructableObject.position
if (BigWorld.camera().position -
objPos).length > TEAMOBJECT_SIMPLIFICATION_DISTANCE:
startPos = objPos
else:
startPos = modelManipulator.getEffectCoordinate(
actionData.trigger)
if startPos is None or (
startPos -
objPos).length > TEAMOBJECT_SIMPLIFICATION_FILTER:
startPos = objPos
return startPos
def launchUpdatable(actionData, environmentData, startPos, endPos,
startVector, effect):
import updatable.UpdatableManager
if updatable.UpdatableManager.g_instance and not environmentData.destructableObject.isDestroyed:
modelManipulator = environmentData.destructableObject.controllers[
'modelManipulator']
modelManipulator.setEffectVisible(actionData.trigger, True)
updatable.UpdatableManager.g_instance.createUpdatableLocal(
UPDATABLE_TYPE.BALLISTIC, actionData.profile, startPos,
startVector, startVector, endPos, actionData.height,
effect)
def delayedLaunchUpdatable(actionData, environmentData, endPos,
effect):
if not environmentData.destructableObject.isDestroyed:
modelManipulator = environmentData.destructableObject.controllers[
'modelManipulator']
startPos = getStartPos(environmentData, modelManipulator)
startVector = endPos - startPos
startVector.normalise()
import updatable.UpdatableManager
if updatable.UpdatableManager.g_instance:
modelManipulator.setEffectVisible(actionData.trigger, True)
updatable.UpdatableManager.g_instance.createUpdatableLocal(
UPDATABLE_TYPE.BALLISTIC, actionData.profile, startPos,
startVector, startVector, endPos, actionData.height,
effect)
profile = db.DBLogic.g_instance.getScenarioShotBallisticProfile(
actionData.profile)
if profile:
endPos = None
if hasattr(actionData, 'targetName'):
target = GameEnvironment.getClientArena(
).getScenarioObjectByDSName(actionData.targetName)
if target:
movementStrategy = target[0].get('movementStrategy')
if movementStrategy and movementStrategy.matrixProvider:
m = Math.Matrix(movementStrategy.matrixProvider)
endPos = m.translation
else:
targetEntity = BigWorld.entities.get(target[2])
if targetEntity:
endPos = targetEntity.position
else:
endPos = target[1]['matrix'].applyToOrigin()
else:
LOG_ERROR(
'ClientScenarioActions: Wrong targetName in ballisticShot:',
actionData.targetName)
elif hasattr(actionData, 'position'):
endPos = actionData.position
if endPos:
modelManipulator = environmentData.destructableObject.controllers[
'modelManipulator']
modelManipulator.setEffectVisible(actionData.trigger, False)
endPos, material = getTerrainPointAndMaterial(
environmentData.destructableObject.spaceID,
applyRadius(endPos, actionData))
effect = actionData.effectName if hasattr(
actionData,
'effectName') else profile.explosionParticles.__dict__.get(
material, profile.explosionParticles.default)
startPos = getStartPos(environmentData, modelManipulator)
startVector = endPos - startPos
startVector.normalise()
scenarioGunner = Dummy()
scenarioGunner.yaw = startVector.yaw - environmentData.destructableObject.yaw
scenarioGunner.pitch = math.radians(actionData.height)
modelManipulator.setAxisValue(
TURRET_TRACKER_AXIS, {actionData.trigger: scenarioGunner})
BigWorld.callback(
0.5,
partial(delayedLaunchUpdatable, actionData,
environmentData, endPos, effect))
return
