def getEntityNominalSpeed(entity):
if isAvatar(entity):
settings = db.DBLogic.g_instance.getDestructibleObjectData(entity)
return settings.flightModel.engine[airplanesConfigurations[
entity.globalID].logicalParts[LOGICAL_PART.ENGINE]].maxSpeed
else:
return 0.0
def isActive(self):
if self._lockTargetId > 0:
target = BigWorld.entities.get(self._lockTargetId)
if target is not None and isAvatar(
target) and EntityStates.inState(target,
EntityStates.GAME):
return self._isFrontAttack(target)
self._lockTargetId = -1
return False
def _execute(self, entityId):
e = BigWorld.entities.get(entityId)
if e is None:
LOG_ERROR('[VSE] Entity does not exist: {0}'.format(entityId))
return -1
elif not isAvatar(e):
LOG_ERROR('[VSE] Entity is not avatar: {0}'.format(entityId))
return -1
else:
return db.DBLogic.g_instance.getPlaneIDByGlobalID(e.globalID)
def _execute(self, entityId):
e = BigWorld.entities.get(entityId)
if e is None:
logEntityDoesNotExistError(entityId, self)
return 0
elif not isAvatar(e):
logNotSupportedEntityError(e, self)
return 0
else:
return e.getSpeed() * METERS_PER_SEC_TO_KMH_FACTOR
def _execute(self, entityId):
e = BigWorld.entities.get(entityId)
if e is None:
logEntityDoesNotExistError(entityId, self)
return 0
elif not isAvatar(e):
logNotSupportedEntityError(e, self)
return 0
else:
return e.getAltitudeAboveObstacle()
def _execute(self, dst, pos, radius):
del dst[:]
e = BigWorld.entities[self.planEntityId]
if isAvatar(e) and e.position.distTo(pos) <= radius:
dst.append(e.id)
avatars = e.entitiesInRange(radius, 'Avatar', pos) + e.entitiesInRange(
radius, 'AvatarBot', pos) + e.entitiesInRange(
radius, 'Bomber', pos)
dst.extend((a.id for a in avatars))
return 'out'
def _tryGetAvatar(self, entityId):
e = BigWorld.entities.get(entityId)
if e is None:
logEntityDoesNotExistError(entityId, self)
return
elif not isAvatar(e):
logNotSupportedEntityError(e, self)
return
else:
return e
def _execute(self, entityId):
e = BigWorld.entities.get(entityId)
if e is None:
logEntityDoesNotExistError(entityId, self)
return 0
elif not isAvatar(e):
logNotSupportedEntityError(e, self)
return 0
else:
return _performanceCharacteristics_db.airplanes[
e.globalID].maxSpeed
def _execute(self, entityId, triggerName, isOn):
e = BigWorld.entities.get(entityId)
if e is None:
logEntityDoesNotExistError(entityId, self)
return
elif not isAvatar(e) and not isTeamObject(e):
logNotSupportedEntityError(e, self)
return
else:
e.controllers['modelManipulator'].setEffectVisible(
triggerName, isOn)
return 'out'
def setOwner(self, owner):
AvatarControllerBase.setOwner(self, owner)
self.__pastTime = 0.0
self.__isMainEntityAvatar = False if not owner else isAvatar(owner)
self._wrdh.setOwner(owner)
if IS_CLIENT:
if owner:
self.__isPlayer = self._owner.isPlayer()
self.__isOwnerAvatar = not isTeamObject(owner)
self.__initClientUpdateCallBack()
elif self.__updateCallBack:
BigWorld.cancelCallback(self.__updateCallBack)
self.__updateCallBack = None
return
def __idleAnimate(self):
if self.__callback is not None:
BigWorld.cancelCallback(self.__callback)
if not IS_EDITOR and isAvatar(
BigWorld.player()) and EntityStates.inState(
BigWorld.player(), EntityStates.GAME):
if self.__passiveTime > 0:
self.__passiveTime -= PilotHeadController.CALLBACK_TIME
else:
rudderY = choice([-1, 0, 1])
self.matrixProvider.yaw = self.maxAngle * rudderY
rudderP = choice([0, -1]) * (1 if not self.reversed else -1)
self.matrixProvider.pitch = self.maxAngle * rudderP
self.__passiveTime = PilotHeadController.PASSIVE_TIME
self.__callback = BigWorld.callback(PilotHeadController.CALLBACK_TIME,
self.__idleAnimate)
return
def setTarget(self, entity):
if not self.__inited:
self.__createTarget()
if entity is not None and isAvatar(entity):
self.__matrixProvider.target = entity.matrix
self.__deflectionTarget(entity)
self.__offsetMtx.target = self.__matrixProvider
self.__centerPointOffsetMtx.target = self.__matrixProvider
if COLLISION_RECORDER:
self.__matrixProvider.targetEntity = entity
else:
self.__matrixProvider.target = None
self.__deflectionTarget(None)
if entity is not None and TEAM_OBJECT_PARALLAX_ENABLED and isTeamObject(
entity):
self.__offsetMtx.target = entity.matrix
self.__centerPointOffsetMtx.target = entity.matrix
else:
self.__offsetMtx.target = None
self.__centerPointOffsetMtx.target = None
if COLLISION_RECORDER:
self.__matrixProvider.targetEntity = None
return
def shakable(self):
if self.isShakeSettingsPresent:
return consts.IS_CLIENT and self._shakeSettings.shakable and isAvatar(
self._player) and EntityStates.inState(self._player,
EntityStates.GAME)
return False
def doExplosiveDamage(owner,
bulletPos,
explosionRadius,
explosionRadiusEffective,
explosionDamage,
damageReason=DAMAGE_REASON.COMMON_EXPLOSION):
try:
spaceID = owner.spaceID
except:
return
closestParts = BigWorld.hm_closestParts(spaceID, bulletPos,
explosionRadius)
if not closestParts:
return
victimsMap = {}
for victim, partId, closestPos, dist in closestParts:
isFriendlyVictim = victim.teamIndex == owner.teamIndex
if not (isFriendlyVictim and isTeamObject(victim)):
victimParts = victimsMap.get(victim, [])
if not victimParts:
victimsMap[victim] = victimParts
victimParts.append((partId, dist))
normalizeVictimsPartsMap(victimsMap)
for victim, victimParts in victimsMap.items():
victimData = db.DBLogic.g_instance.getDestructibleObjectData(
victim)
damagedParts = []
storePartId = -1
storeDamage = -1
if isTeamObject(victim):
numParts = len(victimParts)
else:
numParts = 1
isFriendlyVictim = victim.teamIndex == owner.teamIndex
for partId, dist in victimParts:
victimPartData = getEntityPartDataByID(victim, partId,
victimData)
if victimPartData:
if isFriendlyVictim:
if damageReason == DAMAGE_REASON.BOMB_EXPLOSION:
damage = BOMB_ALLY_DAMAGE
elif damageReason == DAMAGE_REASON.ROCKET_EXPLOSION:
damage = owner.SETTINGS.ROCKET_ALLY_DAMAGE
else:
damage = 1.0
elif isAvatar(
victim
) and damageReason == DAMAGE_REASON.BOMB_EXPLOSION:
damage = BOMB_ENEMY_DAMAGE
else:
damage = 1.0
if dist < explosionRadiusEffective:
damage *= explosionDamage / numParts
elif dist <= explosionRadius:
damage *= explosionDamage * (
explosionRadius - dist) / (
(explosionRadius - explosionRadiusEffective) *
numParts)
else:
LOG_ERROR(
'doExplosiveDamage : dist > explosionRadius, ',
partId, 'for object', victim, victim.id)
if damage > 0:
damagedParts.append({'key': partId, 'value': damage})
else:
LOG_ERROR('Invalid partID', partId, 'for object', victim,
victim.id)
if storeDamage > 0 and storePartId != -1:
damagedParts.append({'key': storePartId, 'value': storeDamage})
if damagedParts:
victim.receiveExplosiveDamage(owner, damagedParts,
owner.entityGroupMask,
owner.teamIndex, damageReason,
owner.unitNumber)
owner.onHitTarget(victimsMap.iterkeys(), damageReason,
ACTION_DEALER.PILOT)
def isEnemyTurret(entity):
return not isAvatar(entity) and isDestructibleObject(
entity) and canAimToEnemyEntity(self._player, entity)
def isEnemy(entity):
return isAvatar(entity) and canAimToEnemyEntity(
self._player, entity)
