def destroy(self):
CallbackDelayer.destroy(self)
if self.__manualSound is not None:
self.__manualSound.stopAll()
self.__manualSound = None
self.__stateTable = None
return
def destroy(self):
super(BotAirdrop, self).destroy()
CallbackDelayer.destroy(self)
self.__removeMarkerArea()
self.__removeDeliveryEffect()
ScriptGameObject.destroy(self)
CallbackDelayer.destroy(self)
def destroy(self):
CallbackDelayer.destroy(self)
self.disable()
self.__activeSelector = None
self.__cam.destroy()
self.__aih = None
return
def destroy(self):
CallbackDelayer.destroy(self)
if self.__soundObject is not None:
self.__soundObject.stopAll()
self.__soundObject = None
self.__stateTable = None
return
def destroy(self):
_SPGFlashGunMarker.destroy(self)
CallbackDelayer.destroy(self)
self.__desiredShotInfoFunc = None
self.__trajectoryDrawer.visible = False
self.__trajectoryDrawer = None
return
def destroy(self):
CallbackDelayer.destroy(self)
self.__cam = None
if self.__aim is not None:
self.__aim.destroy()
self.__aim = None
return
def destroy(self):
_SPGFlashGunMarker.destroy(self)
CallbackDelayer.destroy(self)
self.__desiredShotInfoFunc = None
self.__trajectoryDrawer.visible = False
self.__trajectoryDrawer = None
return
def stop(self):
self.__isStarted = False
import SoundGroups
SoundGroups.g_instance.changePlayMode(0)
aih_global_binding.clear()
for control in self.__ctrls.itervalues():
control.destroy()
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isRecording:
replayCtrl.setPlayerVehicleID(0)
if self.__remoteCameraSender is not None:
self.__remoteCameraSender.destroy()
self.__remoteCameraSender = None
self.onCameraChanged.clear()
self.onCameraChanged = None
self.onPostmortemVehicleChanged.clear()
self.onPostmortemVehicleChanged = None
self.onPostmortemKillerVisionEnter.clear()
self.onPostmortemKillerVisionEnter = None
self.onPostmortemKillerVisionExit.clear()
self.onPostmortemKillerVisionExit = None
self.__targeting.enable(False)
self.__killerVehicleID = None
if self.__onRecreateDevice in g_guiResetters:
g_guiResetters.remove(self.__onRecreateDevice)
BigWorld.player().arena.onPeriodChange -= self.__onArenaStarted
self.settingsCore.onSettingsChanged -= self.__onSettingsChanged
BigWorld.player().consistentMatrices.onVehicleMatrixBindingChanged -= self.__onVehicleChanged
ComponentSystem.destroy(self)
CallbackDelayer.destroy(self)
return
def destroy(self):
CallbackDelayer.destroy(self)
if self.__cloud is not None:
self.__cloud.destroy()
self.__evtManager.clear()
self.__state = GasAttackState.DONE
return
def destroy(self):
CallbackDelayer.destroy(self)
if self.__manualSound is not None:
self.__manualSound.stopAll()
self.__manualSound = None
self.__stateTable = None
return
def destroy(self):
self.__trackScrollCtl = None
if self.__vehicle is not None:
self.deactivate()
self.__destroySystems()
ComponentSystem.destroy(self)
self.__typeDesc = None
self.highlighter.destroy()
if self.__vibrationsCtrl is not None:
self.__vibrationsCtrl.destroy()
self.__vibrationsCtrl = None
if self.__lightFxCtrl is not None:
self.__lightFxCtrl.destroy()
self.__lightFxCtrl = None
if self.__auxiliaryFxCtrl is not None:
self.__auxiliaryFxCtrl.destroy()
self.__auxiliaryFxCtrl = None
if self.__boundEffects is not None:
self.__boundEffects.destroy()
self.__vehicleStickers = None
self.onModelChanged = None
if self.__crashedTracksCtrl is not None:
self.__crashedTracksCtrl.destroy()
self.__crashedTracksCtrl = None
self.__chassisOcclusionDecal.destroy()
self.__chassisOcclusionDecal = None
self.__chassisShadowForwardDecal.destroy()
self.__chassisShadowForwardDecal = None
self.__compoundModel = None
CallbackDelayer.destroy(self)
return
def destroy(self):
self.hangarSpace.onSpaceCreate -= self.__onSpaceCreated
self.hangarSpace.onSpaceDestroy -= self.__onSpaceDestroy
self.__camera = None
self.__isInIdle = None
self.stopCallback(self.__update)
CallbackDelayer.destroy(self)
return
def destroy(self):
CallbackDelayer.destroy(self)
self.disable()
self.__onChangeControlMode = None
self.__cam = None
if self.__aimingSystem is not None:
self.__aimingSystem.destroy()
self.__aimingSystem = None
return
def destroy(self):
super(BotAirdrop, self).destroy()
CallbackDelayer.destroy(self)
if BattleReplay.g_replayCtrl.isPlaying:
g_replayEvents.onTimeWarpStart -= self.__onReplayTimeWarpStart
self.__removeMarkerArea()
self.__removeDeliveryEffect()
ScriptGameObject.destroy(self)
CallbackDelayer.destroy(self)
def deactivate(self):
CallbackDelayer.destroy(self)
ctrl = self.sessionProvider.shared.feedback
if ctrl:
ctrl.onReplyFeedbackReceived -= self.__onReplyFeedbackReceived
ctrl.onRemoveCommandReceived -= self.__onRemoveCommandReceived
removeIDList = self.__markedAreas.keys()
for targetID in removeIDList:
self.__removeMarkedArea(targetID)
def destroy(self):
self.__teamId = None
self.__nodes = None
self.__edges = None
self.__protectionZones = None
self.__activeWarnings = None
ClientArenaComponent.destroy(self)
CallbackDelayer.destroy(self)
return
def destroy(self):
CallbackDelayer.destroy(self)
self.disable()
self.__onChangeControlMode = None
self.__cam = None
if self.__aimingSystem is not None:
self.__aimingSystem.destroy()
self.__aimingSystem = None
return
def _dispose(self):
ctrl = self.sessionProvider.dynamic.missions
if ctrl:
ctrl.onPlayerMissionUpdated -= self.__onPlayerMissionUpdated
ctrl.onPlayerMissionReset -= self.__onPlayerMissionReset
ctrl.onPlayerMissionTimerSet -= self.__onPlayerMissionTimerSet
ctrl.onNearestObjectiveChanged -= self.__onNearestObjectiveChanged
EpicMissionsPanelMeta._dispose(self)
CallbackDelayer.destroy(self)
def destroy(self):
CallbackDelayer.destroy(self)
self.disable()
if self.__activeSelector is not None:
self.__activeSelector.destroy()
self.__activeSelector = None
self.__cam.destroy()
self.__aih = None
return
def destroy(self):
from gui.shared.utils.HangarSpace import g_hangarSpace
g_hangarSpace.onSpaceCreate -= self.__onSpaceCreated
g_hangarSpace.onSpaceDestroy -= self.__onSpaceDestroy
self.__camera = None
self.__isInIdle = None
self.stopCallback(self.__update)
CallbackDelayer.destroy(self)
return
def destroy(self):
self.stopCallback(self.__updateIdleMovement)
self.stopCallback(self.__updateEasingOut)
BigWorld.removeAllIdleCallbacks()
self.__pitchParams = None
self.__distParams = None
self.__camera = None
CallbackDelayer.destroy(self)
HangarCameraIdleController.destroy(self)
return
def destroy(self):
if self.inactiveCargo is not None:
self.inactiveCargo.stopLoading = True
self.inactiveCargo.destroy()
self.inactiveCargo = None
if self.cargo:
self.cargo.stopLoading = True
self.plane = None
CallbackDelayer.destroy(self)
return
def destroy(self):
self.disable()
self.__onChangeControlMode = None
self.__cam = None
self._writeUserPreferences()
self.__aimingSystem.destroy()
self.__aimingSystem = None
self.__aim = None
CallbackDelayer.destroy(self)
return
def destroy(self):
self.settingsCore.onSettingsChanged -= self.__handleSettingsChange
CallbackDelayer.destroy(self)
self.disable()
self.__onChangeControlMode = None
self.__cam = None
if self.__aimingSystem is not None:
self.__aimingSystem.destroy()
self.__aimingSystem = None
return
def destroy(self):
self.disable()
self.__onChangeControlMode = None
self.__cam = None
if self.__aimingSystem is not None:
self.__aimingSystem.destroy()
self.__aimingSystem = None
CallbackDelayer.destroy(self)
CameraWithSettings.destroy(self)
return
def destroy(self):
ctrl = self._sessionProvider.shared.feedback
if ctrl is not None:
ctrl.onVehicleFeedbackReceived -= self.__onVehicleFeedbackReceived
ctrl.onMinimapVehicleAdded -= self.__onVehicleEnterWorld
ctrl.onMinimapVehicleRemoved -= self.__onVehicleLeaveWorld
self.__seenEnemies.clear()
VehicleStateSoundPlayer.destroy(self)
CallbackDelayer.destroy(self)
return
def destroy(self):
if self.inactiveCargo is not None:
self.inactiveCargo.stopLoading = True
self.inactiveCargo.destroy()
self.inactiveCargo = None
if self.cargo:
self.cargo.stopLoading = True
ScriptGameObject.destroy(self)
CallbackDelayer.destroy(self)
return
def enable(self, enableSound):
if enableSound:
self.delayCallback(self.__updatePeriod, self.__update)
else:
CallbackDelayer.destroy(self)
if self.__manualSound is not None:
self.__manualSound.stop()
if self.__gearSound is not None:
self.__gearSound.stop()
return
def enable(self, enableSound):
if enableSound:
self.delayCallback(self.__updatePeriod, self.__update)
else:
CallbackDelayer.destroy(self)
if self.__manualSound is not None:
self.__manualSound.stop()
if self.__gearSound is not None:
self.__gearSound.stop()
return
def destroy(self):
g_settingsCore.onSettingsChanged -= self.__onSettingsChanged
self.disable()
self.__onChangeControlMode = None
self.__cam = None
if self.__aimingSystem is not None:
self.__aimingSystem.destroy()
self.__aimingSystem = None
CallbackDelayer.destroy(self)
return
def stopControl(self):
CallbackDelayer.destroy(self)
self.__settingsCore.onSettingsChanged -= self.__onSettingsChanged
self.__settingsCache.onSyncCompleted -= self.__onSettingsReady
self.__deactivateListeners()
self.__isActive = False
self.__commandReceivedData = None
self.__lastPersonalMsgTimestamp = -_PERSONAL_MESSAGE_MUTE_DURATION
self.__lastCalloutTimestamp = -_CALLOUT_MESSAGES_BLOCK_DURATION
self.__resetRadialMenuData()
return
def onLeaveWorld(self):
if self in ClientSelectableCameraObject.allCameraObjects:
ClientSelectableCameraObject.allCameraObjects.remove(self)
self.stopCallback(self.__update)
if self.__camera == BigWorld.camera():
BigWorld.worldDrawEnabled(False)
self.__camera.destroy()
self.__camera = None
ClientSelectableObject.onLeaveWorld(self)
CallbackDelayer.destroy(self)
return
class _ArtyHitMarkerController(_SPGGunMarkerController):
def __init__(self, gunMakerType, dataProvider, artyEquipmentUDO, areaRadius, interval=0.1):
super(_ArtyHitMarkerController, self).__init__(gunMakerType, dataProvider, enabledFlag=_MARKER_FLAG.ARTY_HIT_ENABLED)
self.__artyEquipmentUDO = artyEquipmentUDO
self.__areaRadius = areaRadius
self.__interval = interval
self.__delayer = CallbackDelayer()
self.__trajectoryDrawer = BigWorld.wg_trajectory_drawer()
def create(self):
super(_ArtyHitMarkerController, self).create()
self.__trajectoryDrawer.setColors(Math.Vector4(0, 255, 0, 255), Math.Vector4(255, 0, 0, 255), Math.Vector4(128, 128, 128, 255))
self.__trajectoryDrawer.setIgnoredIDs([BigWorld.player().playerVehicleID])
def destroy(self):
self.__artyEquipmentUDO = None
if self.__trajectoryDrawer is not None:
self.__trajectoryDrawer.visible = False
self.__trajectoryDrawer = None
if self.__delayer is not None:
self.__delayer.destroy()
self.__delayer = None
super(_ArtyHitMarkerController, self).destroy()
return
def enable(self):
super(_ArtyHitMarkerController, self).enable()
self.__delayer.delayCallback(self.__interval, self.__tick)
self.__trajectoryDrawer.setParams(1000.0, Math.Vector3(0, -self.__artyEquipmentUDO.gravity, 0), (0, 0))
def disable(self):
self.__delayer.stopCallback(self.__tick)
super(_ArtyHitMarkerController, self).disable()
def setVisible(self, flag):
self.__trajectoryDrawer.visible = flag
def getPointsInside(self, positions):
return self._dataProvider.getPointsInside(positions)
def _getCurrentShotInfo(self):
launchPosition = self._position + self.__artyEquipmentUDO.position
launchVelocity = self.__artyEquipmentUDO.launchVelocity
gravity = Math.Vector3(0, -self.__artyEquipmentUDO.gravity, 0)
return (launchPosition, launchVelocity, gravity)
def _updateDispersionData(self):
self._dataProvider.setupFlatRadialDispersion(self.__areaRadius)
def __tick(self):
self.__trajectoryDrawer.update(self._position, self._position + self.__artyEquipmentUDO.position, self.__artyEquipmentUDO.launchVelocity, self.__interval)
return self.__interval
def destroy(self):
if self.__vehicleID is not None:
g_logger.error('destroy called when still attached.')
self.detach()
if self.__model is not None and self.__model.node('').inWorld:
BigWorld.player().delModel(self.__model)
self.__model = None
self.__areaVisual = None
self.__vehicleID = None
self.__motor = None
CallbackDelayer.destroy(self)
return
def destroy(self):
from gui.shared.utils.HangarSpace import g_hangarSpace
g_hangarSpace.onSpaceCreate -= self.__onSpaceCreated
g_hangarSpace.onSpaceDestroy -= self.__onSpaceDestroy
self.stopCallback(self.__updateIdleMovement)
self.stopCallback(self.__updateEasingOut)
BigWorld.removeAllIdleCallbacks()
self.__pitchParams = None
self.__distParams = None
self.__camera = None
CallbackDelayer.destroy(self)
return
def destroy(self):
if self._vehicle is not None:
self.deactivate()
super(CompoundAppearance, self).destroy()
if self.fashion is not None:
self.fashion.removePhysicalTracks()
if self.__terrainCircle is not None:
self.__terrainCircle.destroy()
self.__terrainCircle = None
self.onModelChanged.clear()
self.onModelChanged = None
CallbackDelayer.destroy(self)
return
def deactivate(self):
super(ArenaEquipmentComponent, self).deactivate()
CallbackDelayer.destroy(self)
self.__unsubscribe()
self.removeSyncDataCallback(ARENA_SYNC_OBJECTS.SMOKE, '',
self.__onSmokeScreenUpdated)
self.__smokeScreen.clear()
if self.__inspiringEffect is not None:
self.__inspiringEffect.destroy()
if self.__healingEffect is not None:
self.__healingEffect.destroy()
if self.__repairPointEffect is not None:
self.__repairPointEffect.destroy()
return
def destroy(self):
if self.__vehicle is not None:
self.deactivate()
self.__destroySystems()
ComponentSystem.destroy(self)
self.__typeDesc = None
if self.__boundEffects is not None:
self.__boundEffects.destroy()
self.__vehicleStickers = None
self.onModelChanged = None
self.__chassisDecal.destroy()
self.__chassisDecal = None
self.__compoundModel = None
CallbackDelayer.destroy(self)
return
def stop(self):
self.__isStarted = False
import SoundGroups
SoundGroups.g_instance.changePlayMode(1)
self.__removeBattleCtrlListeners()
for control in self.__ctrls.itervalues():
control.destroy()
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isRecording:
replayCtrl.setPlayerVehicleID(0)
self.onCameraChanged = None
self.__targeting.enable(False)
self.__killerVehicleID = None
g_guiResetters.remove(self.__onRecreateDevice)
BigWorld.player().arena.onPeriodChange -= self.__onArenaStarted
from account_helpers.settings_core.SettingsCore import g_settingsCore
g_settingsCore.onSettingsChanged -= self.__onSettingsChanged
CallbackDelayer.destroy(self)
return
def destroy(self):
BigWorld.player().inputHandler.onCameraChanged -= self.__onCameraChanged
CallbackDelayer.destroy(self)
self.stopSounds()
def __del__(self):
CallbackDelayer.destroy(self)
def __del__(self):
if self._sound is not None:
self._sound.stop()
self._sound = None
CallbackDelayer.destroy(self)
return
class CombatEquipmentManager(object):
def testArtyStrike(self, id=33, offset=Vector3(0, 0, 0)):
if not IS_DEVELOPMENT:
return
else:
p = Vector3(BigWorld.camera().position)
d = BigWorld.camera().direction
collRes = BigWorld.wg_collideSegment(
BigWorld.player().spaceID,
p,
p + d * 1000,
18,
lambda matKind, collFlags, itemId, chunkId: collFlags & 8,
)
if collRes is None:
return
strikePos = collRes[0]
vDir = Vector2(d.x, d.z)
vDir.normalise()
self.setEquipmentApplicationPoint(id, strikePos + offset, vDir)
return
def __init__(self):
self.__callbackDelayer = CallbackDelayer()
self.__selectedAreas = {}
self.__wings = {}
if _ENABLE_DEBUG_DRAW:
self.debugPolyLine = Flock.DebugPolyLine()
self.debugPoints = []
self.debugDirs = []
def onBecomePlayer(self):
pass
def onBecomeNonPlayer(self):
for area in self.__selectedAreas.itervalues():
area.destroy()
for wing in self.__wings.itervalues():
wing.destroy()
self.__callbackDelayer.destroy()
self.__selectedAreas = {}
self.__wings = {}
def updateBomberTrajectory(
self, equipmentID, team, curTime, curPos, curDir, nextTime, nextPos, nextDir, isDroppingPoint
):
if _ENABLE_DEBUG_LOG:
LOG_DEBUG("===== updateBomberTrajectory =====")
LOG_DEBUG(equipmentID, team)
LOG_DEBUG(curPos, curDir, curTime)
LOG_DEBUG(nextPos, nextDir, nextTime)
LOG_DEBUG(isDroppingPoint)
moveDir = nextPos - curPos
moveDir.normalise()
nextDir3d = Vector3(nextDir.x, moveDir.y, nextDir.y)
nextDir3d.normalise()
startP = BombersWing.CurveControlPoint(curPos, Vector3(curDir.x, 0, curDir.y), curTime)
nextP = BombersWing.CurveControlPoint(nextPos, nextDir3d, nextTime)
points = (startP, nextP)
wingID = (team, equipmentID)
wing = self.__wings.get(wingID)
if wing is None or wing.withdrawn:
if wing is not None:
wing.destroy()
self.__wings[wingID] = BombersWing.BombersWing(equipmentID, points)
if _ENABLE_DEBUG_DRAW:
self.debugPoints.append(curPos)
self.debugDirs.append(curDir)
else:
wing.addControlPoint(points, isDroppingPoint)
if _ENABLE_DEBUG_DRAW:
self.debugPoints.append(nextPos)
self.debugDirs.append(nextDir)
self.debugPoints.append(nextPos + Vector3(nextDir.x, 0, nextDir.y) * 10)
self.debugPoints.append(nextPos)
self.debugPolyLine.set(self.debugPoints)
return
def showHittingArea(self, equipmentID, pos, dir, time):
if _ENABLE_DEBUG_LOG:
LOG_DEBUG("===== showHittingArea =====")
LOG_DEBUG(equipmentID)
LOG_DEBUG(pos, dir, time)
correctedCoords = tuple((int(x * 1000.0) for x in pos.tuple()))
areaUID = (int(equipmentID), correctedCoords)
if areaUID in self.__selectedAreas:
return
eq = vehicles.g_cache.equipments()[equipmentID]
if BattleReplay.isPlaying():
BigWorld.callback(0.0, functools.partial(self.__showMarkerCallback, eq, pos, dir, time, areaUID))
else:
self.__showMarkerCallback(eq, pos, dir, time, areaUID)
def __delayedAreaDestroy(self, areaUID):
area = self.__selectedAreas.pop(areaUID, None)
if area is not None:
area.destroy()
return
def __showMarkerCallback(self, eq, pos, dir, time, areaUID):
timer = round(time - BigWorld.serverTime())
area = self.__selectedAreas.pop(areaUID, None)
if area is not None:
area.destroy()
self.__selectedAreas[areaUID] = self.createEquipmentSelectedArea(pos, dir, eq)
self.__callbackDelayer.delayCallback(timer, functools.partial(self.__delayedAreaDestroy, areaUID))
g_sessionProvider.getEquipmentsCtrl().showMarker(eq, pos, dir, timer)
return
@staticmethod
def __calcBombsDistribution(bombsCnt, areaWidth, areaLength):
coeff = areaWidth / areaLength
bombsPerWidth = math.sqrt(bombsCnt * coeff)
bombsPerLength = bombsPerWidth / coeff
return (bombsPerWidth, bombsPerLength)
def showCarpetBombing(self, equipmentID, pos, dir, time):
if _ENABLE_DEBUG_LOG:
LOG_DEBUG("===== showCarpetBombing =====")
LOG_DEBUG(equipmentID)
LOG_DEBUG(pos, dir, time)
bombEquipment = vehicles.g_cache.equipments()[equipmentID]
shellDescr = items.vehicles.getDictDescr(bombEquipment.shellCompactDescr)
shotEffect = vehicles.g_cache.shotEffects[shellDescr["effectsIndex"]]
airstrikeID = shotEffect.get("airstrikeID")
if airstrikeID is None:
LOG_ERROR("EquipmentID %s has no airstrike shot effect settings" % equipmentID)
return
else:
areaWidth, areaLength = bombEquipment.areaWidth, bombEquipment.areaLength
if _ENABLE_DEBUG_LOG:
LOG_DEBUG("Ideal", areaWidth, areaLength)
beginExplosionPos = BigWorld.wg_collideSegment(BigWorld.player().spaceID, pos, pos + dir * 1000.0, 18)
if beginExplosionPos is None:
return
beginExplosionPos = beginExplosionPos[0]
flatDir = Vector3(dir)
flatDir.y = 0.0
flatDir.normalise()
endDropPoint = pos + flatDir * (areaLength * bombEquipment.waveFraction)
endExplosionPos = BigWorld.wg_collideSegment(
BigWorld.player().spaceID, endDropPoint, endDropPoint + dir * 1000.0, 18
)
if endExplosionPos is None:
endExplosionPos = beginExplosionPos + flatDir * (areaLength * bombEquipment.waveFraction)
else:
endExplosionPos = endExplosionPos[0]
areaLength = beginExplosionPos.flatDistTo(endExplosionPos)
averageBombCount = bombEquipment.bombsNumber
bombsPerWidth, bombsPerLength = CombatEquipmentManager.__calcBombsDistribution(
averageBombCount, areaWidth, areaLength
)
delay = time - BigWorld.serverTime()
explosionVelocity = flatDir * bombEquipment.speed
partialAirstrikeFunc = functools.partial(
BigWorld.PyGroundEffectManager().playAirstrike,
airstrikeID,
beginExplosionPos,
explosionVelocity,
areaWidth,
areaLength,
math.ceil(bombsPerWidth),
math.ceil(bombsPerLength),
)
if _ENABLE_DEBUG_LOG:
LOG_DEBUG("delta", delay)
LOG_DEBUG("pos, dir", pos, dir)
LOG_DEBUG(
"Params for artyStrike effect",
airstrikeID,
beginExplosionPos,
flatDir,
areaWidth,
areaLength,
bombsPerWidth,
bombsPerLength,
)
if delay < 0.0:
partialAirstrikeFunc()
else:
self.__callbackDelayer.delayCallback(delay, partialAirstrikeFunc)
if _ENABLE_DEBUG_DRAW:
self.debugStartLine = Flock.DebugLine(pos, beginExplosionPos)
self.debugEndLine = Flock.DebugLine(endDropPoint, endExplosionPos)
self.__callbackDelayer.delayCallback(
delay,
functools.partial(
_DebugFrontLine.launch, beginExplosionPos, endExplosionPos, areaWidth, explosionVelocity
),
)
return
def setEquipmentApplicationPoint(self, equipmentID, point, direction):
myTeam = BigWorld.player().team
wingID = (myTeam, equipmentID)
wing = self.__wings.get(wingID)
if wing is not None:
wing.destroy()
del self.__wings[wingID]
self.cell.setEquipmentApplicationPoint(equipmentID, point, direction)
return
@staticmethod
def createEquipmentSelectedArea(pos, dir, equipment):
area = CombatSelectedArea.CombatSelectedArea()
size = Math.Vector2(equipment.areaWidth, equipment.areaLength)
visual = equipment.areaVisual
color = equipment.areaColor
marker = equipment.areaMarker
if visual is None:
visual = CombatSelectedArea.DEFAULT_RADIUS_MODEL
if color is None:
color = CombatSelectedArea.COLOR_WHITE
if marker is None:
pass
area.setup(pos, dir, size, visual, color, marker)
return area
def destroy(self):
CallbackDelayer.destroy(self)
self.__cam = None
return
def onLeaveWorld(self):
self.__models = []
self.models = []
FlockLike.destroy(self)
CallbackDelayer.destroy(self)
def destroy(self):
self.__avatar = None
CallbackDelayer.destroy(self)
return
class DetachedTurret(BigWorld.Entity):
allTurrets = list()
def __init__(self):
self.__vehDescr = vehicles.VehicleDescr(compactDescr=self.vehicleCompDescr)
self.filter = BigWorld.WGTurretFilter()
self.__detachConfirmationTimer = SynchronousDetachment(self)
self.__detachConfirmationTimer.onInit()
self.__detachmentEffects = None
self.__hitEffects = {TankPartNames.TURRET: None,
TankPartNames.GUN: None}
self.__reactors = []
self.targetFullBounds = True
self.targetCaps = [1]
self.__isBeingPulledCallback = None
return
def reload(self):
pass
def prerequisites(self):
prereqs = [self.__vehDescr.turret['models']['exploded'], self.__vehDescr.gun['models']['exploded']]
prereqs += self.__vehDescr.prerequisites()
return prereqs
def onEnterWorld(self, prereqs):
self.model = prereqs[self.__vehDescr.turret['models']['exploded']]
self.model.addMotor(BigWorld.Servo(self.matrix))
self.__gunModel = prereqs[self.__vehDescr.gun['models']['exploded']]
node = self.model.node(TankNodeNames.GUN_JOINT, Math.Matrix())
node.attach(self.__gunModel)
self.__detachConfirmationTimer.onEnterWorld()
self.__vehDescr.keepPrereqs(prereqs)
turretDescr = self.__vehDescr.turret
if self.isUnderWater == 0:
self.__detachmentEffects = _TurretDetachmentEffects(self.model, turretDescr['turretDetachmentEffects'], self.isCollidingWithWorld == 1)
self.__reactors.append(self.__detachmentEffects)
else:
self.__detachmentEffects = None
self.__hitEffects[TankPartNames.TURRET] = turretHitEffects = _HitEffects(self.model)
self.__hitEffects[TankPartNames.GUN] = gunHitEffects = _HitEffects(self.__gunModel)
self.__reactors.append(turretHitEffects)
self.__reactors.append(gunHitEffects)
self.__componentsDesc = (self.__vehDescr.turret, self.__vehDescr.gun)
for desc in self.__componentsDesc:
desc['hitTester'].loadBspModel()
from helpers.CallbackDelayer import CallbackDelayer
self.__isBeingPulledCallback = CallbackDelayer()
self.__isBeingPulledCallback.delayCallback(self.__checkIsBeingPulled(), self.__checkIsBeingPulled)
DetachedTurret.allTurrets.append(self)
return
def onLeaveWorld(self):
DetachedTurret.allTurrets.remove(self)
self.__detachConfirmationTimer.cancel()
self.__detachConfirmationTimer = None
for reactor in self.__reactors:
if reactor is not None:
reactor.destroy()
self.__isBeingPulledCallback.destroy()
self.__isBeingPulledCallback = None
return
def onStaticCollision(self, energy, point, normal):
if self.__detachmentEffects is not None:
surfaceMaterial = calcSurfaceMaterialNearPoint(point, normal, self.spaceID)
effectIdx = surfaceMaterial.effectIdx
groundEffect = True
distToWater = BigWorld.wg_collideWater(self.position, surfaceMaterial.point)
if distToWater != -1:
vel = Math.Vector3(self.velocity).length
if vel < _MIN_COLLISION_SPEED:
groundEffect = False
effectIdx = material_kinds.EFFECT_MATERIAL_INDEXES_BY_NAMES['water']
self.__detachmentEffects.notifyAboutCollision(energy, point, effectIdx, groundEffect, self.isUnderWater)
return
def showDamageFromShot(self, points, effectsIndex):
maxHitEffectCode, decodedPoints = DamageFromShotDecoder.decodeHitPoints(points, self.__vehDescr)
for shotPoint in decodedPoints:
hitEffects = self.__hitEffects.get(shotPoint.componentName)
if hitEffects is not None:
hitEffects.showHit(shotPoint, effectsIndex)
else:
LOG_ERROR("Detached turret got hit into %s component, but it's impossible" % shotPoint.componentName)
return
def collideSegment(self, startPoint, endPoint, skipGun = False):
res = None
filterMethod = getattr(self.filter, 'segmentMayHitEntity', lambda : True)
if not filterMethod(startPoint, endPoint, 0):
return res
else:
modelsToCheck = (self.model,) if skipGun else (self.model, self.__gunModel)
for model, desc in zip(modelsToCheck, self.__componentsDesc):
toModel = Matrix(model.matrix)
toModel.invert()
collisions = desc['hitTester'].localHitTest(toModel.applyPoint(startPoint), toModel.applyPoint(endPoint))
if collisions is None:
continue
for dist, _, hitAngleCos, matKind in collisions:
if res is None or res.dist >= dist:
matInfo = desc['materials'].get(matKind)
res = SegmentCollisionResult(dist, hitAngleCos, matInfo.armor if matInfo is not None else 0)
return res
def set_isUnderWater(self, prev):
if self.__detachmentEffects is not None:
if self.isUnderWater:
self.__detachmentEffects.stopEffects()
return
def set_isCollidingWithWorld(self, prev):
pass
def changeAppearanceVisibility(self, isVisible):
self.model.visible = isVisible
self.model.visibleAttachments = isVisible
def __checkIsBeingPulled(self):
if self.__detachmentEffects is not None:
if self.isCollidingWithWorld and not self.isUnderWater and self.velocity.lengthSquared > 0.1:
extent = Math.Matrix(self.model.bounds).applyVector(Math.Vector3(0.5, 0.5, 0.5)).length
surfaceMaterial = calcSurfaceMaterialNearPoint(self.position, Math.Vector3(0, extent, 0), self.spaceID)
self.__detachmentEffects.notifyAboutBeingPulled(True, surfaceMaterial.effectIdx)
if surfaceMaterial.matKind == 0:
LOG_ERROR('calcSurfaceMaterialNearPoint failed to find the collision point')
else:
self.__detachmentEffects.notifyAboutBeingPulled(False, None)
return SERVER_TICK_LENGTH
def destroy(self):
CallbackDelayer.destroy(self)
def destroy(self):
CallbackDelayer.destroy(self)
for bomber in self.__bombers:
bomber.destroy()
