def update(self):
self.__cbID = BigWorld.callback(self.UPDATE_PERIOD, self.update)
if not self.isActive:
return
player = BigWorld.player()
if not isPlayerAvatar():
return
camPos = BigWorld.camera().position
camDir = BigWorld.camera().direction
vehicle = BigWorld.entities.get(player.playerVehicleID)
try:
for type, (isTwoState, args) in self.__pendingManualTriggers.iteritems():
params = dict(args)
params['type'] = type
for listener in self.__listeners:
listener.onTriggerActivated(params)
if isTwoState:
self.__activeManualTriggers[type] = params
self.__pendingManualTriggers = {}
for id, params in self.__autoTriggers.iteritems():
wasActive = id in self.__activeAutoTriggers
isActive = False
distance = -1.0
type = params['type']
if type == TRIGGER_TYPE.AREA and vehicle is not None:
triggerRadius = params['radius']
if wasActive:
triggerRadius = triggerRadius + params['exitInterval']
offset = vehicle.position - Math.Vector3(params['position'])
offset.y = 0
distance = offset.length
isActive = distance < triggerRadius
if type == TRIGGER_TYPE.AIM:
camToTrigger = Math.Vector3(params['position']) - camPos
vehicleToTrigger = Math.Vector3(params['position']) - vehicle.position
distance = camToTrigger.length
if distance <= params['maxDistance'] and vehicleToTrigger.dot(camToTrigger) > 0.0:
camToTrigger.normalise()
dp = camToTrigger.dot(camDir)
if dp > 0.0:
sinAngle = math.sqrt(1.0 - dp * dp)
isActive = sinAngle * distance < params['radius']
params['distance'] = distance
if wasActive != isActive:
if isActive:
self.__activeAutoTriggers.add(id)
for listener in self.__listeners:
listener.onTriggerActivated(params)
else:
self.__activeAutoTriggers.discard(id)
for listener in self.__listeners:
listener.onTriggerDeactivated(params)
self.__explodePoints = []
self.__shotPoints = []
except:
LOG_CURRENT_EXCEPTION()
def __destroy(self):
LOG_DEBUG('Hangar successfully destroyed.')
if self.__cam == BigWorld.camera():
self.__cam.spaceID = 0
BigWorld.camera(None)
BigWorld.worldDrawEnabled(False)
self.__cam = None
self.__loadingStatus = 0.0
if self.__vAppearance is not None:
self.__vAppearance.destroy()
self.__vAppearance = None
self.__onLoadedCallback = None
self.__boundingRadius = None
entity = None if self.__vEntityId is None else BigWorld.entity(self.__vEntityId)
BigWorld.SetDrawInflux(False)
MapActivities.g_mapActivities.stop()
if self.__spaceId is not None and BigWorld.isClientSpace(self.__spaceId):
if self.__spaceMappingId is not None:
BigWorld.delSpaceGeometryMapping(self.__spaceId, self.__spaceMappingId)
BigWorld.clearSpace(self.__spaceId)
BigWorld.releaseSpace(self.__spaceId)
self.__spaceMappingId = None
self.__spaceId = None
if entity is None or not entity.inWorld:
return
else:
BigWorld.destroyEntity(self.__vEntityId)
self.__vEntityId = None
BigWorld.wg_disableSpecialFPSMode()
if hasattr(BigWorld.player(), 'inputHandler') and self.__savedInputHandler is not None:
BigWorld.player().inputHandler = self.__savedInputHandler
g_hangarInputHandler.hangarSpace = None
self.__savedInputHandler = None
return
def exhibit(tankNames = None, pivotPoint = None, shift = Vector3(0, 0, 10), assembler = assembleCompoundModel2):
if pivotPoint is None:
p = Vector3(BigWorld.camera().position)
d = BigWorld.camera().direction
spaceID = BigWorld.player().spaceID if BigWorld.player() is not None else BigWorld.camera().spaceID
collRes = BigWorld.wg_collideSegment(spaceID, p, p + d * 1000, 18, 8)
if collRes is None:
pivotPoint = Vector3(0, 0, 0)
else:
strikePos = collRes[0]
pivotPoint = strikePos
if tankNames is None:
tankNames = [ vehicles.g_cache.vehicle(0, x).name for x in xrange(EXAMPLE_COUNT) ]
totalTanks = len(tankNames)
shift_new = Vector3(d)
shift_new.y = 0.0
up = Vector3(0.0, 1.0, 0.0)
right = up * shift_new
shift_new.normalise()
right.normalise()
offset = 6.0
shift_new = shift_new * offset
right = right * offset
for idx, tankName in enumerate(tankNames):
desc = vehicles.VehicleDescr(typeName=tankName)
if idx < totalTanks / 2:
creationPosition = pivotPoint + shift_new * idx
else:
creationPosition = pivotPoint + shift_new * (idx - totalTanks / 2) + right
assembler(getModelNames(desc), creationPosition, desc)
return
def disable(self):
BigWorld.camera(None)
BigWorld.player().positionControl.followCamera(False)
if self.__autoUpdateCallbackId is not None:
BigWorld.cancelCallback(self.__autoUpdateCallbackId)
self.__autoUpdateCallbackId = None
return
def __destroy(self):
LOG_DEBUG('Hangar successfully destroyed.')
MusicController.g_musicController.unloadCustomSounds()
if self.__cam == BigWorld.camera():
self.__cam.spaceID = 0
BigWorld.camera(None)
BigWorld.worldDrawEnabled(False)
self.__cam = None
self.__loadingStatus = 0.0
if self.__vAppearance is not None:
self.__vAppearance.destroy()
self.__vAppearance = None
self.__onLoadedCallback = None
self.__boundingRadius = None
if self.__waitCallback is not None:
BigWorld.cancelCallback(self.__waitCallback)
self.__waitCallback = None
g_keyEventHandlers.remove(self.handleKeyEvent)
g_mouseEventHandlers.remove(self.handleMouseEventGlobal)
BigWorld.SetDrawInflux(False)
MapActivities.g_mapActivities.stop()
if self.__spaceId is not None and BigWorld.isClientSpace(self.__spaceId):
if self.__spaceMappingId is not None:
BigWorld.delSpaceGeometryMapping(self.__spaceId, self.__spaceMappingId)
BigWorld.clearSpace(self.__spaceId)
BigWorld.releaseSpace(self.__spaceId)
self.__spaceMappingId = None
self.__spaceId = None
self.__vEntityId = None
BigWorld.wg_disableSpecialFPSMode()
g_postProcessing.disable()
FovExtended.instance().resetFov()
return
def __destroy(self):
LOG_DEBUG('Hangar successfully destroyed.')
if self.__cam == BigWorld.camera():
self.__cam.spaceID = 0
BigWorld.camera(None)
BigWorld.worldDrawEnabled(False)
self.__cam = None
self.__loadingStatus = 0.0
if self.__vAppearance is not None:
self.__vAppearance.destroy()
self.__vAppearance = None
self.__onLoadedCallback = None
self.__boundingRadius = None
g_keyEventHandlers.remove(self.handleKeyEvent)
g_mouseEventHandlers.remove(self.handleMouseEventGlobal)
entity = None if self.__vEntityId is None else BigWorld.entity(self.__vEntityId)
BigWorld.SetDrawInflux(False)
MapActivities.g_mapActivities.stop()
if self.__spaceId is not None and BigWorld.isClientSpace(self.__spaceId):
if self.__spaceMappingId is not None:
BigWorld.delSpaceGeometryMapping(self.__spaceId, self.__spaceMappingId)
BigWorld.clearSpace(self.__spaceId)
BigWorld.releaseSpace(self.__spaceId)
self.__spaceMappingId = None
self.__spaceId = None
if entity is None or not entity.inWorld:
return
BigWorld.destroyEntity(self.__vEntityId)
self.__vEntityId = None
BigWorld.wg_disableSpecialFPSMode()
g_postProcessing.disable()
def launch(spaceName):
global g_enablePostProcessing
global g_offlineModeEnabled
print 'Entering offline space', spaceName
BigWorld.clearAllSpaces()
BigWorld.worldDrawEnabled(False)
_displayGUI(spaceName)
spaceID = BigWorld.createSpace()
BigWorld.addSpaceGeometryMapping(spaceID, None, spaceName)
_loadCameraTransforms()
camera = BigWorld.FreeCamera()
camera.spaceID = spaceID
BigWorld.camera(camera)
_setCameraTransform(g_curCameraTransform)
BigWorld.camera().fixed = True
BigWorld.projection().fov = math.radians(75.0)
BigWorld.setWatcher('Client Settings/Strafe Rate', 175.0)
BigWorld.setWatcher('Client Settings/Camera Mass', 5.0)
BigWorld.setCursor(GUI.mcursor())
GUI.mcursor().visible = True
GUI.mcursor().clipped = False
g_offlineModeEnabled = True
BigWorld.callback(1.0, _offlineLoadCheck)
g_postProcessing.init()
_enablePostProcessing(g_enablePostProcessing, 'arcade')
return
def disable(self):
self.stopCallback(self.__update)
BigWorld.projection().fov = self.__defaultFov
BigWorld.camera(None)
self.__alignerToLand.disable()
BigWorld.player().positionControl.followCamera(False)
return
def change_game_state(self, **state):
import BigWorld, Avatar, Account
assert self.mod_tessumod, "Mod must be loaded first before changing game state"
if state["mode"] == "battle":
BigWorld.player(Avatar.Avatar())
if "players" in state:
for player in state["players"]:
vehicle_id = random.randint(0, 1000000)
dbid = random.randint(0, 1000000)
BigWorld.player().arena.vehicles[vehicle_id] = {
"accountDBID": dbid,
"name": player["name"],
"isAlive": True
}
if vehicle_id not in BigWorld.entities:
BigWorld.entities[vehicle_id] = BigWorld.Entity()
if "position" in player:
BigWorld.player().arena.positions[vehicle_id] = player["position"]
BigWorld.entities[vehicle_id].position = BigWorld.Vector(*player["position"])
if "camera" in state:
if "position" in state["camera"]:
BigWorld.camera().position = BigWorld.Vector(*state["camera"]["position"])
if "direction" in state["camera"]:
BigWorld.camera().direction = BigWorld.Vector(*state["camera"]["direction"])
elif state["mode"] == "lobby":
BigWorld.player(Account.PlayerAccount())
if "players" in state:
for id, player in enumerate(state["players"]):
BigWorld.player().prebattle.rosters[0][id] = {
"name": player["name"],
"dbID": random.randint(0, 1000000)
}
def testWindow():
BigWorld.camera(BigWorld.CursorCamera())
BigWorld.setCursor(GUI.mcursor())
GUI.mcursor().visible = True
clear()
w = GUI.load('gui/tests/window.gui')
GUI.addRoot(w)
return w
def destroy(self):
if self.__videoCamera is None:
return
self.__videoCamera.destroy()
BigWorld.camera(self.__overriddenCamera)
InputHandler.g_instance.onKeyDown -= self.handleKeyEvent
InputHandler.g_instance.onKeyUp -= self.handleKeyEvent
g_mouseEventHandlers.discard(self.handleMouseEvent)
def disable(self):
self.__aimingSystem.disable()
self.stopCallback(self.__cameraUpdate)
BigWorld.camera(None)
BigWorld.player().positionControl.followCamera(False)
self.__positionOscillator.reset()
FovExtended.instance().resetFov()
FovExtended.instance().enabled = True
def handleKeyEvent(event):
global g_enablePostProcessing
global g_curCameraTransform
global g_enableTAA
if not g_offlineModeEnabled or not BigWorld.camera():
return False
BigWorld.camera().handleKeyEvent(event)
if not event.isKeyDown():
return False
if event.key in MOUSE_TOGGLE_KEYS:
GUI.mcursor().visible = not GUI.mcursor().visible
elif event.key == Keys.KEY_ADD:
adjustSpeed(+MOVE_SPEED_ADJUST)
elif event.key == Keys.KEY_NUMPADMINUS:
adjustSpeed(-MOVE_SPEED_ADJUST)
elif event.key == Keys.KEY_F:
newFixed = not BigWorld.camera().fixed
BigWorld.camera().fixed = newFixed
GUI.mcursor().visible = newFixed
GUI.mcursor().clipped = not newFixed
elif event.key == Keys.KEY_1:
_setCameraTransform(0)
elif event.key == Keys.KEY_2:
_setCameraTransform(1)
elif event.key == Keys.KEY_3:
_setCameraTransform(2)
elif event.key == Keys.KEY_4:
_setCameraTransform(3)
elif event.key == Keys.KEY_5:
_setCameraTransform(4)
elif event.key == Keys.KEY_6:
_setCameraTransform(5)
elif event.key == Keys.KEY_7:
_setCameraTransform(6)
elif event.key == Keys.KEY_8:
_setCameraTransform(7)
elif event.key == Keys.KEY_M:
g_curCameraTransform = _clampCameraTransformIdx(g_curCameraTransform + 1)
_setCameraTransform(g_curCameraTransform)
elif event.key == Keys.KEY_N:
g_curCameraTransform = _clampCameraTransformIdx(g_curCameraTransform - 1)
_setCameraTransform(g_curCameraTransform)
elif event.key == Keys.KEY_R:
_addCameraTransform()
_saveCameraTransforms()
elif event.key == Keys.KEY_P:
g_enablePostProcessing = not g_enablePostProcessing
_enablePostProcessing(g_enablePostProcessing, 'arcade')
elif event.key == Keys.KEY_C:
g_enableCinematicPostProcessing = not g_enableCinematicPostProcessing
_enablePostProcessing(g_enableCinematicPostProcessing, 'cinematic')
elif event.key == Keys.KEY_T:
g_enableTAA = not g_enableTAA
modeAA = 0
if g_enableTAA:
modeAA = 3
BigWorld.setCustomAAMode(modeAA)
return True
def disable(self):
self.stopCallback(self.__update)
BigWorld.projection().fov = self.__defaultFov
BigWorld.camera(None)
self.__alignerToLand.disable()
if isPlayerAvatar():
BigWorld.player().positionControl.followCamera(False)
self.__isModeOverride = False
return
def create(self, model, list, args):
if BigWorld.player() is not None and BigWorld.player().vehicle is None:
return
else:
if args.get('showShockWave', True):
dir = BigWorld.camera().direction.scale(self._scale)
shake = getattr(BigWorld.camera(), 'shake', None)
if shake is not None:
shake(self._duration, dir)
return
def handleMouseEvent(event):
if not g_offlineModeEnabled or not BigWorld.camera():
return False
if GUI.mcursor().visible:
return False
if event.dz > 0:
adjustFOV(-FOV_ADJUST)
elif event.dz < 0:
adjustFOV(+FOV_ADJUST)
return BigWorld.camera().handleMouseEvent(event)
def enable(self, doEnable):
if self.__isEnabled == doEnable:
return
from cameras import FovExtended
if not doEnable:
self.__isEnabled = False
BigWorld.camera(self.__savedCamera)
BigWorld.wg_enableSuperShot(False, False)
for k, v in self.__savedWatchers.iteritems():
BigWorld.setWatcher(k, v)
FovExtended.instance().enabled = True
LOG_DEBUG('Vertical screenshot camera is disabled')
return
self.__isEnabled = True
self.__savedCamera = BigWorld.camera()
FovExtended.instance().enabled = False
arenaBB = BigWorld.wg_getSpaceBounds()
centerXZ = Math.Vector2(0.5 * (arenaBB[0] + arenaBB[2]), 0.5 * (arenaBB[1] + arenaBB[3]))
halfSizesXZ = Math.Vector2(0.5 * (arenaBB[2] - arenaBB[0]), 0.5 * (arenaBB[3] - arenaBB[1]))
camFov = math.radians(15.0)
camPos = Math.Vector3(centerXZ.x, 0, centerXZ.z)
aspectRatio = 1.0
if not BigWorld.isVideoWindowed():
aspectRatio = BigWorld.getFullScreenAspectRatio()
else:
aspectRatio = BigWorld.screenWidth() / BigWorld.screenHeight()
camPos.y = max(halfSizesXZ.x / math.sin(0.5 * camFov * aspectRatio), halfSizesXZ.y / math.sin(0.5 * camFov))
camMatr = Math.Matrix()
camMatr.setRotateYPR(Math.Vector3(0.0, math.pi * 0.5, 0.0))
camMatr.translation = camPos
camMatr.invert()
self.__cam = BigWorld.FreeCamera()
self.__cam.set(camMatr)
BigWorld.camera(self.__cam)
BigWorld.wg_enableSuperShot(True, False)
self.__savedWatchers = {}
for name in self.__watcherNames:
try:
self.__savedWatchers[name] = BigWorld.getWatcher(name)
if name.startswith('Visibility'):
BigWorld.setWatcher(name, False)
except TypeError:
LOG_WARNING('Failed to get/set watcher', name)
BigWorld.setWatcher('Client Settings/std fog/enabled', False)
BigWorld.projection().fov = camFov
BigWorld.setWatcher('Render/Fov', camFov)
BigWorld.setWatcher('Render/Near Plane', max(0.1, camPos.y - 1000.0))
BigWorld.setWatcher('Render/Far Plane', camPos.y + 1000.0)
BigWorld.setWatcher('Render/Objects Far Plane/Enabled', False)
BigWorld.setWatcher('Render/Shadows/qualityPreset', 7)
BigWorld.setWatcher('Client Settings/Script tick', False)
LOG_DEBUG('Vertical screenshot camera is enabled')
def isInAngle(vehiclePos): camToVeh = (vehiclePos - BigWorld.camera().position) camToVeh.normalise() angle = camToVeh.dot(BigWorld.camera().direction) if angle < -1.0 or angle > 1.0: return False angle = math.acos(angle) return angle < g_modSetting['dirAngleToBlur']
def disable(self):
BigWorld.camera(None)
if self.__autoUpdateCallbackId is not None:
BigWorld.cancelCallback(self.__autoUpdateCallbackId)
self.__autoUpdateCallbackId = None
if self.__waitVehicleCallbackId is not None:
BigWorld.cancelCallback(self.__waitVehicleCallbackId)
self.__waitVehicleCallbackId = None
self.__applyFOV(self.__fov)
self.__showVehicle(True)
return
def testArtyStrike(self, id = 33, offset = Vector3(0, 0, 0)):
if not IS_DEVELOPMENT:
return
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)
def disable(self):
self.__cam.wg_setModelsToCollideWith([])
self.__cam.sptHiding = False
BigWorld.camera(None)
if self.__autoUpdateCallbackId is not None:
BigWorld.cancelCallback(self.__autoUpdateCallbackId)
self.__autoUpdateCallbackId = None
if self.__cameraUpdateCallbackId is not None:
BigWorld.cancelCallback(self.__cameraUpdateCallbackId)
self.__cameraUpdateCallbackId = None
if self.__shiftKeySensor is not None:
self.__shiftKeySensor.reset(Math.Vector3())
return
def disable(self):
BigWorld.camera(None)
if self.__waitVehicleCallbackId is not None:
BigWorld.cancelCallback(self.__waitVehicleCallbackId)
self.__waitVehicleCallbackId = None
self.__showVehicle(True)
self.stopCallback(self.__cameraUpdate)
self.__aimingSystem.disable()
self.__movementOscillator.reset()
self.__impulseOscillator.reset()
self.__noiseOscillator.reset()
self.__accelerationSmoother.reset()
self.__autoUpdateDxDyDz.set(0)
FovExtended.instance().resetFov()
def handleKeyEvent(self, event):
if self.__videoCamera is None:
return
if BigWorld.isKeyDown(Keys.KEY_CAPSLOCK) and event.isKeyDown() and event.key == Keys.KEY_F3:
self.__enabled = not self.__enabled
if self.__enabled:
self.__overriddenCamera = BigWorld.camera()
self.__videoCamera.enable()
else:
self.__videoCamera.disable()
BigWorld.camera(self.__overriddenCamera)
if self.__enabled:
return self.__videoCamera.handleKeyEvent(event.key, event.isKeyDown())
return False
def shake(targetModel, maxDist = 100, energy = 0.1):
dist = Vector3(targetModel.position - BigWorld.player().position).length
if dist < maxDist:
normDist = dist / maxDist
try:
BigWorld.rumble((maxDist - dist) / maxDist, 0.0)
BigWorld.callback(0.1, lambda : BigWorld.rumble(0, 0))
except:
pass
shDist = energy - normDist * energy
try:
BigWorld.camera().shake(1.0 - normDist, (shDist, shDist, shDist / 2))
except:
pass
def shake(targetModel):
dist = Vector3(targetModel.position - BigWorld.player().position).length
if dist < 100:
BigWorld.player()
try:
BigWorld.rumble(100 - dist, 0)
BigWorld.callback(0.1, partial(BigWorld.rumble, 0, 0))
except:
pass
shDist = 0.25 - dist / 250
try:
BigWorld.camera().shake(0.1, (shDist, shDist, shDist / 2))
except:
pass
def __setupHangarShadowMap(self):
if self.__smRemoveCb is not None:
BigWorld.cancelCallback(self.__smRemoveCb)
self.__smRemoveCb = None
if BigWorld.spaceLoadStatus() < 1.0:
self.__smCb = BigWorld.callback(0, self.__setupHangarShadowMap)
return
else:
self.__smCb = None
if 'observer' in self.__vDesc.type.tags:
self.__removeHangarShadowMap()
return
vehiclePath = self.__vDesc.chassis['models']['undamaged']
vehiclePath = vehiclePath[:vehiclePath.rfind('/normal')]
dsVehicle = ResMgr.openSection(vehiclePath)
shadowMapTexFileName = _CFG['fakeShadowMapDefaultTexName']
if dsVehicle is not None:
for fileName, _ in dsVehicle.items():
if fileName.lower().find('_hangarshadowmap.dds') != -1:
shadowMapTexFileName = vehiclePath + '/' + fileName
BigWorld.wg_setChunkModelTexture(BigWorld.camera().spaceID, 0, 0,
_CFG['fakeShadowMapModelName'],
'diffuseMap',
shadowMapTexFileName)
return
def makePostmortemCameraMatrix():
matrix = Math.WGCombinedMP()
translationSrc = Math.WGTranslationOnlyMP()
translationSrc.source = BigWorld.player().consistentMatrices.attachedVehicleMatrix
matrix.translationSrc = translationSrc
matrix.rotationSrc = BigWorld.camera().invViewMatrix
return matrix
def __breakWithDirection(self, vehicle, isLeftTrackBroken):
cameraDirection = Math.Vector3(BigWorld.camera().direction)
cameraDirection.y = 0
vehicleMatrix = Math.Matrix(vehicle.matrix)
vehicleMatrix.setElement(3, 0, 0)
vehicleMatrix.setElement(3, 1, 0)
vehicleMatrix.setElement(3, 2, 0)
vehicleMatrix.invert()
cameraDirection = vehicleMatrix.applyVector(cameraDirection)
brokenTrackAngle = 0
if isLeftTrackBroken:
brokenTrackAngle = math.pi
dirAngleRelative = math.atan2(cameraDirection.z, cameraDirection.x)
minDirDelta = math.pi * 2
vibrationToPlay = ''
for angleVibration in TrackBreakingController.__ANGLES_VIBRATIONS:
curAngle = angleVibration[0]
curAngle += dirAngleRelative
if curAngle > math.pi * 2:
curAngle -= math.pi * 2
if curAngle < 0:
curAngle += math.pi * 2
curDirDelta = abs(curAngle - brokenTrackAngle)
if curDirDelta > math.pi:
curDirDelta = math.pi * 2 - curDirDelta
if curDirDelta < minDirDelta:
minDirDelta = curDirDelta
vibrationToPlay = angleVibration[1]
OnceController(vibrationToPlay)
def __updateSound(self, angleDiff):
if self.__manualSound is None:
return
else:
if self.__gearSound is not None and angleDiff >= _PlayerTurretRotationSoundEffect.__MIN_ANGLE_TO_ENABLE_GEAR:
if self.__currentSpeedState != self.__SPEED_FAST and self.__currentSpeedState != self.__SPEED_PRE_FAST:
nextSpeedState = self.__SPEED_PRE_FAST
else:
nextSpeedState = self.__currentSpeedState
elif angleDiff >= _PlayerTurretRotationSoundEffect.__MIN_ANGLE_TO_ENABLE_MANUAL:
nextSpeedState = self.__SPEED_SLOW
else:
nextSpeedState = self.__SPEED_IDLE
stateFn = self.__stateTable[self.__currentSpeedState][nextSpeedState]
if stateFn is not None:
stateFn()
self.__currentSpeedState = nextSpeedState
if g__attachToCam:
__p = BigWorld.camera().position
else:
__p = BigWorld.player().position
isTurretAlive = BigWorld.player().deviceStates.get('turretRotator', None) is None
if self.__gearDamagedParam is not None:
self.__gearDamagedParam.value = 0.0 if isTurretAlive else 1.0
if self.__manGearDamagedParam is not None:
self.__manGearDamagedParam.value = 0.0 if isTurretAlive else 1.0
if self.__manualSound is not None:
self.__manualSound.position = __p
if self.__gearSound is not None:
self.__gearSound.position = __p
return
def __timeWarp(self, time):
if not self.isPlaying or not self.__enableTimeWarp:
return
else:
BigWorld.wg_enableGUIBackground(True, False)
if self.__isFinished:
self.setPlaybackSpeedIdx(self.__savedPlaybackSpeedIdx)
self.__isFinished = False
self.__warpTime = time
self.__rewind = time < self.__replayCtrl.getTimeMark(REPLAY_TIME_MARK_CURRENT_TIME)
AreaDestructibles.g_destructiblesManager.onBeforeReplayTimeWarp(self.__rewind)
self.__updateGunOnTimeWarp = True
EffectsList.EffectsListPlayer.clear()
if self.__rewind:
playerControlMode = BigWorld.player().inputHandler.ctrl
self.__wasVideoBeforeRewind = _isVideoCameraCtrl(playerControlMode)
self.__videoCameraMatrix.set(BigWorld.camera().matrix)
g_replayEvents.onMuteSound(True)
BigWorld.PyGroundEffectManager().stopAll()
self.__enableInGameEffects(False)
if not self.__replayCtrl.beginTimeWarp(time):
self.__cleanupAfterTimeWarp()
return
if self.__timeWarpCleanupCb is None:
self.__timeWarpCleanupCb = BigWorld.callback(0.0, self.__cleanupAfterTimeWarp)
g_replayEvents.onTimeWarpStart()
g_replayEvents.onMuteSound(True)
return
def __updateSound(self, angleDiff):
if self.__manualSound is None:
return
else:
if self.__gearSound is not None and angleDiff >= _PlayerTurretRotationSoundEffect.__MIN_ANGLE_TO_ENABLE_GEAR:
if self.__currentSpeedState != self.__SPEED_FAST and self.__currentSpeedState != self.__SPEED_PRE_FAST:
nextSpeedState = self.__SPEED_PRE_FAST
else:
nextSpeedState = self.__currentSpeedState
elif angleDiff >= _PlayerTurretRotationSoundEffect.__MIN_ANGLE_TO_ENABLE_MANUAL:
nextSpeedState = self.__SPEED_SLOW
else:
nextSpeedState = self.__SPEED_IDLE
stateFn = self.__stateTable[
self.__currentSpeedState][nextSpeedState]
if stateFn is not None:
stateFn()
self.__currentSpeedState = nextSpeedState
if g__attachToCam:
__p = BigWorld.camera().position
else:
__p = BigWorld.player().position
isTurretAlive = BigWorld.player().deviceStates.get(
'turretRotator', None) is None
if self.__gearDamagedParam is not None:
self.__gearDamagedParam.value = 0.0 if isTurretAlive else 1.0
if self.__manGearDamagedParam is not None:
self.__manGearDamagedParam.value = 0.0 if isTurretAlive else 1.0
if self.__manualSound is not None:
self.__manualSound.position = __p
if self.__gearSound is not None:
self.__gearSound.position = __p
return
def __setupCamera(self):
self.__cam = BigWorld.CursorCamera()
self.__cam.spaceID = self.__spaceId
self.__cam.pivotMaxDist = _CFG['cam_start_dist']
self.__cam.pivotMinDist = 0.0
self.__cam.maxDistHalfLife = _CFG['cam_fluency']
self.__cam.turningHalfLife = _CFG['cam_fluency']
self.__cam.movementHalfLife = 0.0
self.__cam.pivotPosition = _CFG['cam_pivot_pos']
mat = Math.Matrix()
mat.setRotateYPR((math.radians(_CFG['cam_start_angles'][0]), math.radians(_CFG['cam_start_angles'][1]), 0.0))
self.__cam.source = mat
mat = Math.Matrix()
mat.setTranslate(_CFG['cam_start_target_pos'])
self.__cam.target = mat
BigWorld.camera(self.__cam)
def matchState(self):
'''
>>> p.getCurrentVisibilityDistances()
(244.4397548224926, 121.99988086102009)
p.getCurrentVisionDist() -> 624.999375
p.getCurrentMaxMainShootRange()
p.getTorpedoesShootRange()
p.getCurrentAirDefenceDistance()
'''
camera = BigWorld.camera()
player = BigWorld.player()
if player:
seaVisible, airVisible = player.getCurrentVisibilityDistances()
ranges = {
'seaVisible': seaVisible,
'airVisible': airVisible,
'vision': player.getCurrentVisionDist(),
'gun': player.getCurrentMaxMainShootRange(),
'torpedo': player.getTorpedoesShootRange(),
'airdefense': player.getCurrentAirDefenceDistance(),
}
else:
ranges = None
return {
'ranges': ranges,
'camera': {
'dir': tuple(camera.direction),
'fov': camera.fov,
},
'players': [player.state() for player in self.players]
}
def __updateCameraByMouseMove(self, dx, dy, dz):
if self.__cam is not BigWorld.camera():
return
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
dist = self.__cam.pivotMaxDist
currentMatrix = Math.Matrix(self.__cam.invViewMatrix)
currentYaw = currentMatrix.yaw
yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx)
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
pitch -= dy * cfg['cam_sens']
dist -= dz * cfg['cam_dist_sens']
camPitchConstr = self.__camConstraints[0]
startPitch, endPitch = camPitchConstr
pitch = mathUtils.clamp(math.radians(startPitch), math.radians(endPitch), pitch)
distConstr = cfg['preview_cam_dist_constr'] if self.__selectedEmblemInfo else self.__camConstraints[2]
minDist, maxDist = distConstr
dist = mathUtils.clamp(minDist, maxDist, dist)
self.__locatedOnEmbelem = False
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
self.__cam.pivotMaxDist = dist
if self.settingsCore.getSetting('dynamicFov') and abs(distConstr[1] - distConstr[0]) > 0.001:
relativeDist = (dist - distConstr[0]) / (distConstr[1] - distConstr[0])
_, minFov, maxFov = self.settingsCore.getSetting('fov')
fov = mathUtils.lerp(minFov, maxFov, relativeDist)
BigWorld.callback(0, partial(FovExtended.instance().setFovByAbsoluteValue, math.radians(fov), 0.1))
def onControlModeChanged(self, forceControlMode=None):
player = BigWorld.player()
if not self.isPlaying or not isPlayerAvatar():
return
else:
entity = BigWorld.entities.get(self.playerVehicleID)
if (entity is None
or not entity.isStarted) and forceControlMode is None:
controlMode = self.getControlMode()
if controlMode == CTRL_MODE_NAME.SNIPER:
return
controlMode = self.getControlMode(
) if forceControlMode is None else forceControlMode
if forceControlMode is None and not self.isControllingCamera and controlMode in _IGNORED_SWITCHING_CTRL_MODES:
return
if self.__equipmentId is None and controlMode == CTRL_MODE_NAME.MAP_CASE_ARCADE:
return
preferredPos = self.getGunRotatorTargetPoint()
if controlMode == CTRL_MODE_NAME.MAP_CASE:
_, preferredPos, _ = self.getGunMarkerParams(
preferredPos, Math.Vector3(0.0, 0.0, 1.0))
player.inputHandler.onControlModeChanged(
controlMode,
camMatrix=BigWorld.camera().matrix,
preferredPos=preferredPos,
saveZoom=False,
saveDist=False,
equipmentID=self.__equipmentId,
curVehicleID=self.__replayCtrl.playerVehicleID)
return
def enable(self, targetPos, saveDist):
self.__prevTime = 0.0
self.__aimingSystem.enable(targetPos)
self.__positionHysteresis.update(Vector3(0.0, 0.0, 0.0))
self.__timeHysteresis.update(BigWorld.timeExact())
camTarget = MatrixProduct()
self.__cam.target = camTarget
self.__cam.source = self.__sourceMatrix
self.__cam.wg_applyParams()
BigWorld.camera(self.__cam)
BigWorld.player().positionControl.moveTo(self.__aimingSystem.hitPoint)
BigWorld.player().positionControl.followCamera(False)
self.__rotation = 0.0
self.__cameraUpdate()
self.delayCallback(0.0, self.__cameraUpdate)
self.__needReset = 1
def minimapResetCamera(cam):
minimap = g_windowsManager.battleWindow.minimap
if minimap is None:
return
if minimap._Minimap__cameraHandle is not None:
minimap._Minimap__ownUI.delEntry(minimap._Minimap__cameraHandle)
global gSPGSniperEnabled
if gSPGSniperEnabled:
#m = Math.WGStrategicAreaViewMP()
#m.source = cam._StrategicCamera__aimingSystem._matrix
#m.baseScale = (1.0, 1.0)
m = cam._StrategicCamera__aimingSystem._matrix
else:
m = Math.WGStrategicAreaViewMP()
m.source = BigWorld.camera().invViewMatrix
m.baseScale = (1.0, 1.0)
minimap._Minimap__cameraHandle = minimap._Minimap__ownUI.addEntry(
m, minimap.zIndexManager.getIndexByName(Minimap.CAMERA_STRATEGIC))
minimap._Minimap__ownUI.entryInvoke(
minimap._Minimap__cameraHandle,
('gotoAndStop', [Minimap.CURSOR_STRATEGIC]))
minimap._Minimap__parentUI.call('minimap.entryInited', [])
def __timeWarp(self, time):
if not self.isPlaying or not self.__enableTimeWarp:
return
g_replayEvents.onTimeWarpStart()
if self.__isFinished:
self.setPlaybackSpeedIdx(self.__savedPlaybackSpeedIdx)
self.__isFinished = False
self.__warpTime = time
self.__rewind = time < self.__replayCtrl.getTimeMark(
REPLAY_TIME_MARK_CURRENT_TIME)
AreaDestructibles.g_destructiblesManager.onBeforeReplayTimeWarp(
self.__rewind)
self.__updateGunOnTimeWarp = True
EffectsList.EffectsListPlayer.clear()
if self.__rewind:
playerControlModeName = BigWorld.player().inputHandler.ctrlModeName
self.__wasVideoBeforeRewind = playerControlModeName == CTRL_MODE_NAME.VIDEO
self.__videoCameraMatrix.set(BigWorld.camera().matrix)
BigWorld.PyGroundEffectManager().stopAll()
BigWorld.wg_clearDecals()
g_replayEvents.onMuteSound(True)
self.__enableInGameEffects(False)
if self.__rewind:
self.gameplay.postStateEvent(ReplayEventID.REPLAY_REWIND)
if not self.__replayCtrl.beginTimeWarp(time):
self.__cleanupAfterTimeWarp()
return
self.__rewind = False
def restartCameraTransition(self, duration):
if self.__cam is not None and not self.__cameraTransition.isInTransition(
):
self.__isCamInTransition = True
self.__cameraTransition.start(BigWorld.camera().matrix, self.__cam,
duration)
return
def makePostmortemCameraMatrix():
matrix = Math.WGCombinedMP()
translationSrc = Math.WGTranslationOnlyMP()
translationSrc.source = BigWorld.player(
).consistentMatrices.attachedVehicleMatrix
matrix.translationSrc = translationSrc
matrix.rotationSrc = BigWorld.camera().invViewMatrix
return matrix
def disable(self):
from gui import g_guiResetters
if self.__onRecreateDevice in g_guiResetters:
g_guiResetters.remove(self.__onRecreateDevice)
self.__setModelsToCollideWith([])
self.__cam.speedTreeTarget = None
BigWorld.camera(None)
if self.__shiftKeySensor is not None:
self.__shiftKeySensor.reset(Math.Vector3())
self.stopCallback(self.__cameraUpdate)
self.__movementOscillator.reset()
self.__impulseOscillator.reset()
self.__noiseOscillator.reset()
self.__accelerationSmoother.reset()
self.__autoUpdateDxDyDz.set(0)
self.__inputInertia.teleport(self.__calcRelativeDist())
FovExtended.instance().resetFov()
def ModCallBack(): player = BigWorld.player() if hasattr(player, 'isOnArena') and player.isOnArena: validControlMode = False for controlMode in player.inputHandler.ctrls: if controlMode in g_modSetting['controlModes'] and player.inputHandler.ctrl == player.inputHandler.ctrls[controlMode]: validControlMode = True break for vehicle in player.vehicles: if not vehicle.isAlive(): continue isFriend = player.team == vehicle.publicInfo['team'] if isFriend: if not g_modSetting['isFriendBlur'] or player.playerVehicleID == vehicle.id: continue else: if not g_modSetting['isEnemyBlur']: continue isTarget = BigWorld.target() and BigWorld.target().id == vehicle.id if isTarget: vehicle.removeEdge() vehicle.drawEdge(2 if isFriend else 1, 0) continue if not validControlMode: vehicle.removeEdge() continue distToVeh = (BigWorld.camera().position - vehicle.position).length if distToVeh > g_modSetting['distanceToBlur']: if not isInAngle(vehicle.position) or distToVeh > g_modSetting['disAngleToBlur']: vehicle.removeEdge() continue if g_modSetting['isFullBlur'] and isRayAtVehicle(BigWorld.camera().position, vehicle.appearance.modelsDesc['gun']['model'].position): vehicle.removeEdge() continue vehicle.drawEdge(3 if g_modSetting['isCustomColors'] else 0, 0 if g_modSetting['isFullBlur'] else 1) BigWorld.callback(0.1, ModCallBack) return
def enable(self,
targetPos,
saveDist,
switchToPos=None,
switchToPlace=None):
BigWorld.wg_trajectory_drawer().setStrategicMode(False)
self.__prevTime = 0.0
if switchToPlace == SwitchToPlaces.TO_TRANSITION_DIST:
self.__camDist = math_utils.clamp(self._cfg['distRange'][0],
self._cfg['distRange'][1],
self._cfg['transitionDist'])
elif switchToPlace == SwitchToPlaces.TO_RELATIVE_POS and switchToPos is not None:
minDist, maxDist = self._cfg['distRange']
self.__camDist = (maxDist - minDist) * switchToPos + minDist
elif switchToPlace == SwitchToPlaces.TO_NEAR_POS and switchToPos is not None:
minDist, maxDist = self._cfg['distRange']
self.__camDist = math_utils.clamp(minDist, maxDist, switchToPos)
elif self.settingsCore.getSetting(SPGAim.AUTO_CHANGE_AIM_MODE):
self.__camDist = math_utils.clamp(self._cfg['distRange'][0],
self._cfg['transitionDist'],
self.__camDist)
self.__desiredCamDist = self.__camDist
self.__scrollSmoother.start(self.__desiredCamDist)
self.__enableSwitchers()
self.__aimingSystem.enable(targetPos)
self.__positionHysteresis.update(Vector3(0.0, 0.0, 0.0))
self.__timeHysteresis.update(BigWorld.timeExact())
camTarget = MatrixProduct()
self.__rotation = max(self.__aimingSystem.direction.pitch,
self._cfg['minimalPitch'])
cameraDirection = self.__getCameraDirection()
self.__targetMatrix.translation = self.aimingSystem.aimPoint - cameraDirection.scale(
self.__camDist)
self.__cam.target = camTarget
self.__cam.target.b = self.__targetMatrix
self.__sourceMatrix = math_utils.createRotationMatrix(
(cameraDirection.yaw, -cameraDirection.pitch, 0.0))
self.__cam.source = self.__sourceMatrix
self.__cam.forceUpdate()
BigWorld.camera(self.__cam)
BigWorld.player().positionControl.moveTo(self.__aimingSystem.hitPoint)
BigWorld.player().positionControl.followCamera(False)
self.__cameraUpdate()
self.delayCallback(0.01, self.__cameraUpdate)
self.__needReset = 1
return
def __onSettingsChanged(self, diff):
if 'increasedZoom' in diff:
self.__cfg['increasedZoom'] = diff['increasedZoom']
if not self.__cfg['increasedZoom']:
self.__cfg['zoom'] = self.__zoom = self.__cfg['zooms'][:3][-1]
self.delayCallback(0.0, self.__applyZoom, self.__cfg['zoom'])
if 'fov' in diff and self.camera is BigWorld.camera():
self.delayCallback(0.01, self.__applyZoom, self.__cfg['zoom'])
def enable(self, targetPos, saveZoom):
player = BigWorld.player()
if not saveZoom:
self.__zoom = self.__cfg['zoom']
self.__fov = BigWorld.projection().fov
self.__dxdydz = [0, 0, 0]
self.__applyFOV(self.__fov / self.__zoom)
self.__setupCamera(targetPos)
vehicle = BigWorld.entity(player.playerVehicleID)
if vehicle is None:
self.__whiteVehicleCallbackId = BigWorld.callback(
0.1, self.__waitVehicle)
else:
self.__showVehicle(False)
BigWorld.camera(self.__cam)
self.__cameraUpdate()
return
def testAllocate(spaceID):
import items.vehicles
vehicleDesc = items.vehicles.VehicleDescr(
typeName=items.vehicles.g_cache.vehicle(0, 1).name)
entityId = BigWorld.createEntity('OfflineEntity', spaceID, 0,
BigWorld.camera().position, (0, 0, 0),
dict())
return CrashedTrackController(vehicleDesc, BigWorld.entity(entityId))
def __destroyCameras(self):
if self.__c11nCamera is not None:
self.__c11nCamera.stop()
if self.__hangarCameraManager is not None and self.__hangarCameraManager.camera is not None:
hangarCamera = self.__hangarCameraManager.camera
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
hangarCamera.maxDistHalfLife = cfg['cam_fluency']
hangarCamera.turningHalfLife = cfg['cam_fluency']
hangarCamera.movementHalfLife = cfg['cam_fluency']
BigWorld.camera(hangarCamera)
if self.__hangarCameraManager is not None:
self.__hangarCameraManager.setC11nDistMode(False)
self.__hangarCameraManager.handleInactiveCamera = False
self.__c11nCamera = None
self.__hangarCameraManager = None
return
def enable(self,
preferredPos=None,
closesDist=False,
postmortemParams=None,
turretYaw=None,
gunPitch=None,
isRemoteCamera=False):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(self.__aimOffset)
self.measureDeltaTime()
camDist = None
vehicle = BigWorld.player().getVehicleAttached()
initialVehicleMatrix = BigWorld.player().getOwnVehicleMatrix(
) if vehicle is None else vehicle.matrix
vehicleMProv = initialVehicleMatrix
if not self.__postmortemMode:
if closesDist:
camDist = self.__cfg['distRange'][0]
elif postmortemParams is not None:
self.__aimingSystem.yaw = postmortemParams[0][0]
self.__aimingSystem.pitch = postmortemParams[0][1]
camDist = postmortemParams[1]
else:
camDist = self.__cfg['distRange'][1]
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying:
camDist = None
vehicle = BigWorld.entity(replayCtrl.playerVehicleID)
if vehicle is not None:
vehicleMProv = vehicle.matrix
if camDist is not None:
self.setCameraDistance(camDist)
else:
self.__inputInertia.teleport(self.__calcRelativeDist())
self.vehicleMProv = vehicleMProv
self.__setModelsToCollideWith(self.__vehiclesToCollideWith)
self.__isRemoteCamera = isRemoteCamera
BigWorld.camera(self.__cam)
self.__aimingSystem.enable(preferredPos, turretYaw, gunPitch)
self.__aimingSystem.aimMatrix = self.__calcAimMatrix()
self.__cameraUpdate()
self.delayCallback(0.0, self.__cameraUpdate)
from gui import g_guiResetters
g_guiResetters.add(self.__onRecreateDevice)
return
def handleKeyEvent(self, event):
if self.__videoCamera is None:
return
else:
if BigWorld.isKeyDown(Keys.KEY_CAPSLOCK) and event.isKeyDown(
) and event.key == Keys.KEY_F3:
self.__enabled = not self.__enabled
if self.__enabled:
self.__overriddenCamera = BigWorld.camera()
self.__videoCamera.enable()
else:
self.__videoCamera.disable()
BigWorld.camera(self.__overriddenCamera)
if self.__enabled:
return self.__videoCamera.handleKeyEvent(
event.key, event.isKeyDown())
return False
def handleKeyEvent(event):
global g_curCameraTransform
if not g_offlineModeEnabled or not BigWorld.camera():
return False
BigWorld.camera().handleKeyEvent(event)
if not event.isKeyDown():
return False
if event.key in MOUSE_TOGGLE_KEYS:
GUI.mcursor().visible = not GUI.mcursor().visible
elif event.key == Keys.KEY_ADD:
adjustFOV(+FOV_ADJUST)
elif event.key == Keys.KEY_NUMPADMINUS:
adjustFOV(-FOV_ADJUST)
elif event.key == Keys.KEY_F:
newFixed = not BigWorld.camera().fixed
BigWorld.camera().fixed = newFixed
GUI.mcursor().visible = newFixed
GUI.mcursor().clipped = not newFixed
elif event.key == Keys.KEY_1:
_setCameraTransform(0)
elif event.key == Keys.KEY_2:
_setCameraTransform(1)
elif event.key == Keys.KEY_3:
_setCameraTransform(2)
elif event.key == Keys.KEY_4:
_setCameraTransform(3)
elif event.key == Keys.KEY_5:
_setCameraTransform(4)
elif event.key == Keys.KEY_6:
_setCameraTransform(5)
elif event.key == Keys.KEY_7:
_setCameraTransform(6)
elif event.key == Keys.KEY_8:
_setCameraTransform(7)
elif event.key == Keys.KEY_M:
g_curCameraTransform = _clampCameraTransformIdx(g_curCameraTransform +
1)
_setCameraTransform(g_curCameraTransform)
elif event.key == Keys.KEY_N:
g_curCameraTransform = _clampCameraTransformIdx(g_curCameraTransform -
1)
_setCameraTransform(g_curCameraTransform)
elif event.key == Keys.KEY_R:
_addCameraTransform()
return True
def enable(self, doEnable):
if self.__isEnabled == doEnable:
return
if not doEnable:
self.__isEnabled = False
BigWorld.camera(self.__savedCamera)
BigWorld.wg_enableSuperShot(False, False)
for k, v in self.__savedWatchers.iteritems():
BigWorld.setWatcher(k, v)
LOG_DEBUG('Vertical screenshot camera is disabled')
return
self.__isEnabled = True
self.__savedCamera = BigWorld.camera()
arenaBB = BigWorld.wg_getSpaceBounds()
centerXZ = Math.Vector2(0.5 * (arenaBB[0] + arenaBB[2]), 0.5 * (arenaBB[1] + arenaBB[3]))
halfSizesXZ = Math.Vector2(0.5 * (arenaBB[2] - arenaBB[0]), 0.5 * (arenaBB[3] - arenaBB[1]))
camFov = math.radians(15.0)
camPos = Math.Vector3(centerXZ.x, 0, centerXZ.z)
aspectRatio = 1.0
if not BigWorld.isVideoWindowed():
aspectRatio = BigWorld.getFullScreenAspectRatio()
else:
aspectRatio = BigWorld.screenWidth() / BigWorld.screenHeight()
camPos.y = max(halfSizesXZ.x / math.sin(0.5 * camFov * aspectRatio), halfSizesXZ.y / math.sin(0.5 * camFov))
camMatr = Math.Matrix()
camMatr.setRotateYPR(Math.Vector3(0.0, math.pi * 0.5, 0.0))
camMatr.translation = camPos
camMatr.invert()
self.__cam = BigWorld.FreeCamera()
self.__cam.set(camMatr)
BigWorld.camera(self.__cam)
BigWorld.wg_enableSuperShot(True, False)
self.__savedWatchers = {}
for name in self.__watcherNames:
self.__savedWatchers[name] = BigWorld.getWatcher(name)
if name.startswith('Visibility'):
BigWorld.setWatcher(name, False)
BigWorld.setWatcher('Client Settings/std fog/enabled', False)
BigWorld.setWatcher('Render/Fov', camFov)
BigWorld.setWatcher('Render/Near Plane', max(0.1, camPos.y - 1000.0))
BigWorld.setWatcher('Render/Far Plane', camPos.y + 1000.0)
BigWorld.setWatcher('Client Settings/Script tick', False)
LOG_DEBUG('Vertical screenshot camera is enabled')
def _onInput(self, enable):
global isFreeHangarCamera
global hangarCameraOldMatrix
if IS_CLIENT:
if g_hangarSpace is not None:
clientHangarSpace = g_hangarSpace.space
if clientHangarSpace:
if enable and not isFreeHangarCamera:
hangarCameraOldMatrix = BigWorld.camera().parentMatrix
clientHangarSpace.hangarCamera.setState(
CameraState.SuperFree)
isFreeHangarCamera = True
if not enable and isFreeHangarCamera:
BigWorld.camera().parentMatrix = hangarCameraOldMatrix
clientHangarSpace.hangarCamera.setDirectAngle(0, 0)
clientHangarSpace.hangarCamera.leaveState()
isFreeHangarCamera = False
return 'out'
def assembleCompoundModel2(models, position, vehicleDesc):
worldMatrix = mathUtils.createTranslationMatrix(position)
chassisFashion = BigWorld.WGVehicleFashion()
VehicleAppearance.setupTracksFashion(chassisFashion, vehicleDesc)
fashions.append(chassisFashion)
gunFashion = BigWorld.WGGunRecoil('G')
fashions.append(gunFashion)
assembler = prepareCompoundAssembler(vehicleDesc, ModelStates.UNDAMAGED, BigWorld.camera().spaceID if BigWorld.player().spaceID == 0 else BigWorld.player().spaceID)
BigWorld.loadResourceListBG((assembler,), functools.partial(setupTank, chassisFashion, gunFashion, vehicleDesc, worldMatrix))
def getAimedAtPositionWithinBorders(aimOffsetX, aimOffsetY):
ray, _ = getWorldRayAndPoint(aimOffsetX, aimOffsetY)
player = BigWorld.player()
staticHitPoint = BigWorld.wg_collideSegment(
player.spaceID,
BigWorld.camera().position,
BigWorld.camera().position + ray * 100000, 128)
if staticHitPoint is not None:
staticHitPoint = staticHitPoint.closestPoint
boundingBox = player.arena.arenaType.boundingBox
if not boundingBox[0][0] <= staticHitPoint.x <= boundingBox[1][
0] or not boundingBox[0][1] <= staticHitPoint.z <= boundingBox[
1][1]:
return
return staticHitPoint
else:
return
return
def removeVehicleToCollideWith(self, vehicleAppearance):
modelsDesc = vehicleAppearance.modelsDesc
for model in (modelsDesc['hull']['model'], modelsDesc['turret']['model']):
for existingModel in self.__modelsToCollideWith:
if existingModel is model:
self.__modelsToCollideWith.remove(model)
if BigWorld.camera() == self.__cam:
self.__setModelsToCollideWith(self.__modelsToCollideWith)
def _makeWorldMatrix(positionMatrix):
sr = GUI.screenResolution()
aspect = sr[0] / sr[1]
proj = BigWorld.projection()
worldMatrix = Math.Matrix()
worldMatrix.perspectiveProjection(proj.fov, aspect, proj.nearPlane, proj.farPlane)
worldMatrix.preMultiply(BigWorld.camera().matrix)
worldMatrix.preMultiply(positionMatrix)
return worldMatrix
def _calcScale(worldMatrix, size):
"""Calculate scaling in clip space
:param worldMatrix: result of function _makeWorldMatrix.
:param size: size of gun marker.
:return: float containing scale in clip space.
"""
pointMat = Math.Matrix()
pointMat.set(BigWorld.camera().matrix)
transl = Math.Matrix()
transl.setTranslate(Math.Vector3(size, 0, 0))
pointMat.postMultiply(transl)
pointMat.postMultiply(BigWorld.camera().invViewMatrix)
p = pointMat.applyToOrigin()
pV4 = worldMatrix.applyV4Point(Math.Vector4(p[0], p[1], p[2], 1))
oV4 = worldMatrix.applyV4Point(Math.Vector4(0, 0, 0, 1))
pV3 = Math.Vector3(pV4[0], pV4[1], pV4[2]).scale(1.0 / pV4[3])
oV3 = Math.Vector3(oV4[0], oV4[1], oV4[2]).scale(1.0 / oV4[3])
return math.fabs(pV3[0] - oV3[0]) + math.fabs(pV3[1] - oV3[1])
def enable(self,
preferredPos=None,
closesDist=False,
postmortemParams=None):
camSource = None
camDist = None
camTarget = BigWorld.player().getOwnVehicleMatrix()
camTargetTransOnly = Math.WGTranslationOnlyMP()
camTargetTransOnly.source = camTarget
camTarget = Math.MatrixProduct()
shift = Math.Matrix()
shift.setIdentity()
camTarget.a = shift
camTarget.b = camTargetTransOnly
if not self.__postmortemMode:
if preferredPos is not None:
self.__calcStartAngles(camTarget, preferredPos)
if closesDist:
camDist = self.__cfg['distRange'][0]
elif postmortemParams is not None:
self.__yaw = postmortemParams[0][0]
self.__pitch = postmortemParams[0][1]
camDist = postmortemParams[1]
camSource = Math.Matrix()
camSource.setRotateYPR((self.__yaw, self.__pitch, 0))
else:
camDist = self.__cfg['distRange'][1]
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying:
camDist = None
vehicle = BigWorld.entity(replayCtrl.playerVehicleID)
if vehicle is not None:
camTarget = vehicle.matrix
if camDist is not None:
self.__camDist = camDist
self.__cam.pivotMaxDist = camDist
if camSource is not None:
self.__cam.source = camSource
self.__cam.target = camTarget
self.__cam.sptHiding = True
self.__cam.wg_setModelsToCollideWith(self.__modelsToCollideWith)
BigWorld.camera(self.__cam)
self.__cameraUpdate()
return
def _onInput(self, position, targetPos):
localPos = targetPos - position
localPos.normalise()
yawOnTarget = math.atan2(localPos.x, localPos.z)
pitchOnTarget = -math.asin(clamp(-1.0, localPos.y, 1.0))
if self.prevYaw:
alternativeYaw = yawOnTarget - math.pi if yawOnTarget > 0 else yawOnTarget + math.pi
if math.fabs(alternativeYaw -
self.prevYaw) < math.fabs(yawOnTarget - self.prevYaw):
yawOnTarget = alternativeYaw
pitchOnTarget = math.pi - pitchOnTarget if pitchOnTarget > 0 else -math.pi - pitchOnTarget
self.prevYaw = yawOnTarget
self._matrix.setRotateYPR((yawOnTarget, pitchOnTarget, 0))
self._matrix.translation = position
if self.prevMatrixYaw:
if math.fabs(self.prevMatrixYaw - self._matrix.yaw) > 0.1:
self.skipFrames = SetCameraPosAndTarget.FRAMES_TO_SKIP
elif math.fabs(self.prevMatrixPitch - self._matrix.pitch) > 0.1:
self.skipFrames = SetCameraPosAndTarget.FRAMES_TO_SKIP
elif math.fabs(self.prevMatrixRoll - self._matrix.roll) > 0.1:
self.skipFrames = SetCameraPosAndTarget.FRAMES_TO_SKIP
else:
self.prevMatrixYaw = self._matrix.yaw
self.prevMatrixPitch = self._matrix.pitch
self.prevMatrixRoll = self._matrix.roll
if self.skipFrames > 0:
self.skipFrames = self.skipFrames - 1
self._parent.translation = self._matrix.translation
else:
self._parent.set(self._matrix)
if math.fabs(
math.fabs(self.prevMatrixYaw) -
math.fabs(self._matrix.yaw)) < 0.05 and math.fabs(
math.fabs(self.prevMatrixPitch) -
math.fabs(self._matrix.pitch)) < 0.05:
self.prevMatrixYaw = self._matrix.yaw
self.prevMatrixPitch = self._matrix.pitch
self.prevMatrixRoll = self._matrix.roll
if IS_CLIENT:
if g_hangarSpace is not None:
clientHangarSpace = g_hangarSpace.space
if clientHangarSpace:
strategy = clientHangarSpace.hangarCamera.getStateStrategy(
)
if strategy and isinstance(
strategy, BigWorld.CameraStrategySuperFree):
strategy.parentProvider = self._parent
BigWorld.camera().parentMatrix = self._parent
clientHangarSpace.hangarCamera.setDirectAngle(
yawOnTarget, pitchOnTarget)
else:
import WorldEditor
self._inverted.set(self._parent)
self._inverted.invert()
WorldEditor.camera(0).view = self._inverted
return 'out'
def onBulletExplosion(effectId, startPos, end):
MAX_DIST_TO_CAMERA = 300
distToCamera = BigWorld.camera().position.distTo(end)
if distToCamera < MAX_DIST_TO_CAMERA:
bulletDir = end - startPos
EffectManager.g_instance.createWorldEffect(
effectId, end, {
'variant': 'OTHER',
'rotation': Math.Vector3(bulletDir.yaw, bulletDir.pitch, 0)
})
