def bspline3_get_points_on_segment(s, points):
plen = len(points)
p0i = clamp(s - 2, 0, plen - 1)
p1i = clamp(s - 1, 0, plen - 1)
p2i = clamp(s, 0, plen - 1)
p3i = clamp(s + 1, 0, plen - 1)
return points[p0i], points[p1i], points[p2i], points[p3i]
def __updateCameraByMouseMove(self, dx, dy, dz):
if self.__cam is None:
return
elif self.__cam != BigWorld.camera() and not self.__handleInactiveCamera:
return
else:
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
self.__cam.movementMode = FAST_CAMERA_MOVEMENT_MODE
if self.__rotationEnabled:
sourceMat = Math.Matrix(self.__cam.source)
yaw = sourceMat.yaw
pitch = sourceMat.pitch
currentMatrix = Math.Matrix(self.__cam.invViewMatrix)
currentYaw = currentMatrix.yaw
yaw = self.__yawCameraFilter.getNextYaw(currentYaw, yaw, dx)
pitch -= dy * cfg['cam_sens']
camPitchConstr = self.__camConstraints[0]
startPitch, endPitch = camPitchConstr
pitch = math_utils.clamp(math.radians(startPitch), math.radians(endPitch), pitch)
mat = Math.Matrix()
mat.setRotateYPR((yaw, pitch, 0.0))
self.__cam.source = mat
if self.__zoomEnabled:
if dz < 0.0:
dist = self.__cam.pivotMaxDist
else:
dist = self.__cam.targetMaxDist
dist -= dz * cfg['cam_dist_sens']
minDist, maxDist = self.__camConstraints[2]
dist = math_utils.clamp(minDist, maxDist, dist)
self.__cam.pivotMaxDist = dist
self.__updateDynamicFov(dist=dist, rampTime=0.1)
return
def __calculateIdealState(self, deltaTime):
aimPoint = self.__aimingSystem.aimPoint
direction = self.__aimingSystem.direction
impactPitch = max(direction.pitch, self._cfg['minimalPitch'])
self.__rotation = max(self.__rotation, impactPitch)
distRange = self._cfg['distRange']
distanceCurSq = (
aimPoint -
BigWorld.player().getVehicleAttached().position).lengthSquared
distanceMinSq = distRange[0]**2.0
forcedPitch = impactPitch
if distanceCurSq < distanceMinSq:
forcedPitch = atan2(sqrt(distanceMinSq - distanceCurSq),
sqrt(distanceCurSq))
angularShift = self._cfg['angularSpeed'] * deltaTime
angularShift = angularShift if self.__choosePitchLevel(
aimPoint) else -angularShift
minPitch = max(forcedPitch, impactPitch)
maxPitch = max(forcedPitch, self._cfg['maximalPitch'])
self.__rotation = math_utils.clamp(minPitch, maxPitch,
self.__rotation + angularShift)
desiredDistance = self.__getDesiredCameraDistance()
cameraDirection = self.__getCameraDirection()
desiredDistance = self.__resolveCollisions(aimPoint, desiredDistance,
cameraDirection)
desiredDistance = math_utils.clamp(distRange[0], distRange[1],
desiredDistance)
translation = aimPoint - cameraDirection.scale(desiredDistance)
rotation = Vector3(cameraDirection.yaw, -cameraDirection.pitch, 0.0)
return (translation, rotation)
def __calcAimOffset(self, aimLocalTransform=None):
aimingSystemMatrix = self.__aimingSystem.matrix
worldCrosshair = Matrix(self.__crosshairMatrix)
if aimLocalTransform is not None:
worldCrosshair.postMultiply(aimLocalTransform)
worldCrosshair.postMultiply(aimingSystemMatrix)
aimOffset = cameras.projectPoint(worldCrosshair.translation)
return Vector2(math_utils.clamp(-0.95, 0.95, aimOffset.x), math_utils.clamp(-0.95, 0.95, aimOffset.y))
def set_color(self, color):
self.color = color
self.color = (
math_utils.clamp(self.color[0], 0, 255),
math_utils.clamp(self.color[1], 0, 255),
math_utils.clamp(self.color[2], 0, 255),
math_utils.clamp(self.color[3], 0, 255),
)
def __getClampedCursor(self):
cursorPosition = GUI.mcursor().position
cursorPosition.x = math_utils.clamp(-self.CURSOR_POSITION_CLAMP_VALUE,
self.CURSOR_POSITION_CLAMP_VALUE,
cursorPosition.x)
cursorPosition.y = math_utils.clamp(-self.CURSOR_POSITION_CLAMP_VALUE,
self.CURSOR_POSITION_CLAMP_VALUE,
cursorPosition.y)
return cursorPosition
def __clampToLimits(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = math_utils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.getPitchLimits(turretYaw))
adjustment = max(0, self.__returningOscillator.deviation.y)
pitchLimits[0] -= adjustment
pitchLimits[1] += adjustment
gunPitch = math_utils.clamp(pitchLimits[0], pitchLimits[1] + self.__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
def setCameraLocation(self, targetPos=None, pivotPos=None, yaw=None, pitch=None, dist=None, camConstraints=None, ignoreConstraints=False, movementMode=FAST_CAMERA_MOVEMENT_MODE):
if self.__cam is None:
_logger.error('Unable to set camera location, because camera reference is None.')
return
else:
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
sourceMat = Math.Matrix(self.__cam.source)
yawS = sourceMat.yaw if yaw is None else yaw
pitchS = sourceMat.pitch if pitch is None else pitch
if dist is None:
dist = self.__cam.pivotMaxDist
if movementMode != IMMEDIATE_CAMERA_MOVEMENT_MODE:
self.__cam.movementMode = movementMode
if camConstraints is None or camConstraints[0] is None:
self.__camConstraints[0] = cfg['cam_pitch_constr']
else:
self.__camConstraints[0] = camConstraints[0]
if camConstraints is None or camConstraints[1] is None:
self.__camConstraints[1] = cfg['cam_yaw_constr']
else:
self.__camConstraints[1] = camConstraints[1]
if camConstraints is None or camConstraints[2] is None:
self.__updateCameraLimits()
else:
self.__camConstraints[2] = camConstraints[2]
if not ignoreConstraints:
if yaw is not None:
camYawConstr = self.__camConstraints[1]
startYaw, endYaw = camYawConstr
self.__yawCameraFilter.setConstraints(math.radians(startYaw), math.radians(endYaw))
self.__yawCameraFilter.setYawLimits(camYawConstr)
yawS = self.__yawCameraFilter.toLimit(yawS)
if pitch is not None:
camPitchConstr = self.__camConstraints[0]
startPitch, endPitch = (math.radians(pc) for pc in camPitchConstr)
pitchS = math_utils.clamp(startPitch, endPitch, pitchS)
minDist, maxDist = self.__camConstraints[2]
dist = math_utils.clamp(minDist, maxDist, dist)
if yaw is not None or pitch is not None:
mat = Math.Matrix()
pitchS = math_utils.clamp(-math.pi / 2 * 0.99, math.pi / 2 * 0.99, pitchS)
mat.setRotateYPR((yawS, pitchS, 0.0))
self.__cam.source = mat
if targetPos is not None:
targetMat = self.__cam.target
targetMat.setTranslate(targetPos)
self.__cam.target = targetMat
self.__cam.target.setTranslate(targetPos)
if pivotPos is not None:
self.__cam.pivotPosition = pivotPos
self.__cam.pivotMaxDist = dist
if movementMode == IMMEDIATE_CAMERA_MOVEMENT_MODE:
self.__cam.pivotMinDist = 0.0
self.__cam.forceUpdate()
return
def clampToLimits(base, self, turretYaw, gunPitch):
if config.get('battle/camera/enabled') and config.get('battle/camera/sniper/noCameraLimit/enabled'):
if not BigWorld.isKeyDown(KEY_RIGHTMOUSE) and self._SniperAimingSystem__yawLimits is not None and config.get('battle/camera/sniper/noCameraLimit/mode') == "hotkey":
turretYaw = math_utils.clamp(self._SniperAimingSystem__yawLimits[0], self._SniperAimingSystem__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.getPitchLimits(turretYaw))
adjustment = max(0, self._SniperAimingSystem__returningOscillator.deviation.y)
pitchLimits[0] -= adjustment
pitchLimits[1] += adjustment
gunPitch = math_utils.clamp(pitchLimits[0], pitchLimits[1] + self._SniperAimingSystem__pitchCompensating, gunPitch)
return (turretYaw, gunPitch)
return base(self, turretYaw, gunPitch)
def __calculateAimOffset(self, aimWorldPos):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying and replayCtrl.isControllingCamera:
aimOffset = replayCtrl.getAimClipPosition()
else:
aimOffset = cameras.projectPoint(aimWorldPos)
aimOffset = Vector2(math_utils.clamp(-0.95, 0.95, aimOffset.x),
math_utils.clamp(-0.95, 0.95, aimOffset.y))
if replayCtrl.isRecording:
replayCtrl.setAimClipPosition(aimOffset)
return aimOffset
def getCellIdFromPosition(desiredShotPoint, boundingBox, dimensions):
mapXLength = boundingBox[1][0] - boundingBox[0][0]
mapYLength = boundingBox[1][1] - boundingBox[0][1]
xOffset = -boundingBox[0][0]
yOffset = -boundingBox[0][1]
x = math_utils.clamp(boundingBox[0][0] + 0.1, boundingBox[1][0] - 0.1,
desiredShotPoint.x)
y = math_utils.clamp(boundingBox[0][1] + 0.1, boundingBox[1][1] - 0.1,
desiredShotPoint.z)
mapGridX = math.floor((xOffset + x) / mapXLength * dimensions)
mapGridY = dimensions - (math.floor(
(yOffset + y) / mapYLength * dimensions) + 1)
return mapGridX * dimensions + mapGridY
def __setupCamera(self):
from gui.ClientHangarSpace import hangarCFG
cfg = hangarCFG()
self.__cam = BigWorld.CursorCamera()
self.__cam.isHangar = True
self.__cam.spaceID = self.__spaceId
camDistConstr = cfg['cam_dist_constr']
minDist, maxDist = camDistConstr
self.__cam.pivotMaxDist = math_utils.clamp(minDist, maxDist, cfg['cam_start_dist'])
self.__cam.pivotMinDist = 0.0
self.__cam.maxDistHalfLife = cfg['cam_fluency']
self.__cam.turningHalfLife = cfg['cam_fluency']
self.__cam.movementHalfLife = cfg['cam_fluency']
self.__cam.pivotPosition = cfg['cam_pivot_pos']
self.__camConstraints[0] = cfg['cam_pitch_constr']
self.__camConstraints[1] = cfg['cam_yaw_constr']
self.__camConstraints[2] = (0.0, 0.0)
camYawConstr = self.__camConstraints[1]
startYaw, endYaw = camYawConstr
self.__yawCameraFilter = HangarCameraYawFilter(math.radians(startYaw), math.radians(endYaw), cfg['cam_sens'])
self.__yawCameraFilter.setYawLimits(camYawConstr)
mat = Math.Matrix()
yaw = self.__yawCameraFilter.toLimit(math.radians(cfg['cam_start_angles'][0]))
mat.setRotateYPR((yaw, 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
self.__cam.forceUpdate()
BigWorld.camera(self.__cam)
self.__cameraIdle = HangarCameraIdle(self.__cam)
self.__cameraParallax = HangarCameraParallax(self.__cam)
self.__cam.setDynamicCollisions(True)
def __cameraUpdate(self):
currentTime = BigWorld.timeExact()
self.__elapsedTime += currentTime - self.__prevTime
self.__prevTime = currentTime
interpolationCoefficient = self.__easingMethod(
self.__elapsedTime, 1.0, self.__totalInterpolationTime)
interpolationCoefficient = math_utils.clamp(0.0, 1.0,
interpolationCoefficient)
iSource = self.__initialState.source
iTarget = self.__initialState.target.b.translation
iPivotPosition = self.__initialState.pivotPosition
fSource = self.__finalState.source
fTarget = self.__finalState.target.b.translation
fPivotPosition = self.__finalState.pivotPosition
self.__cam.source = Math.slerp(iSource, fSource,
interpolationCoefficient)
self.__cam.target.b.translation = math_utils.lerp(
iTarget, fTarget, interpolationCoefficient)
self.__cam.pivotPosition = math_utils.lerp(iPivotPosition,
fPivotPosition,
interpolationCoefficient)
BigWorld.projection().fov = math_utils.lerp(self.__initialFov,
self.__finalFov,
interpolationCoefficient)
if self.__elapsedTime > self.__totalInterpolationTime:
self.delayCallback(0.0, self.disable)
return 10.0
def __updateZoom(self):
cfg = self._cfg
zooms = self.__getZooms()
self.__zoom = cfg['zoom'] = math_utils.clamp(zooms[0], zooms[-1],
self.__zoom)
if self.camera is BigWorld.camera():
self.delayCallback(0.0, self.__applyZoom, self.__zoom)
def __interpolateStates(self, deltaTime, translation, rotation):
lerpParam = math_utils.clamp(
0.0, 1.0, deltaTime * self._cfg['interpolationSpeed'])
self.__sourceMatrix = slerp(self.__sourceMatrix, rotation, lerpParam)
self.__targetMatrix.translation = math_utils.lerp(
self.__targetMatrix.translation, translation, lerpParam)
return (self.__sourceMatrix, self.__targetMatrix)
def on_max_spell_text_changed(self, e):
if len(e.text) > 0 and e.text.isnumeric():
map_settings.settings.max_spell = math_utils.clamp(
int(e.text), 0, len(spell.spells_definitions))
else:
map_settings.settings.max_spell = len(spell.spells_definitions)
self.update_general_panel()
def update(self):
if self._state == HintBase.STATE_INACTIVE or self._state == HintBase.STATE_COMPLETE:
return
elif self.hangarSpace is None or self.hangarSpace.space is None:
return
else:
camera = self.hangarSpace.space.camera
if camera is None:
return
elif self.__prevCameraDirection is None:
self.__prevCameraDirection = copy(camera.direction)
self.__prevCameraDirection.normalise()
return
curDirection = copy(camera.direction)
curDirection.normalise()
cosAngle = self.__prevCameraDirection.dot(curDirection)
cosAngle = math_utils.clamp(-1.0, 1.0, cosAngle)
self.__curAngle += abs(math.acos(cosAngle))
self.__prevCameraDirection = curDirection
resultCommand = None
if self._state == HintBase.STATE_HINT:
if self.__curAngle > self.__neededAngle:
self._state = HintBase.STATE_COMPLETE
resultCommand = HINT_COMMAND.SHOW_COMPLETED_WITH_HINT
elif self._state == HintBase.STATE_DEFAULT:
if time.time() - self._timeStart > self._timeout:
self._state = HintBase.STATE_HINT
resultCommand = HINT_COMMAND.SHOW
elif self.__curAngle > self.__cancelAngle:
self._state = HintBase.STATE_COMPLETE
resultCommand = HINT_COMMAND.SHOW_COMPLETED
return resultCommand
def __getTurretYawForAnchor(self, anchorId, defaultYaw):
turretYaw = defaultYaw
if anchorId is not None and hasTurretRotator(self.__vDesc):
anchorHelper = self.__getAnchorHelperById(anchorId)
if anchorHelper is not None:
if anchorHelper.turretYaw is not None:
turretYaw = anchorHelper.turretYaw
else:
if anchorHelper.attachedPartIdx == TankPartIndexes.HULL:
needsCorrection = anchorId.slotType in (
GUI_ITEM_TYPE.EMBLEM, GUI_ITEM_TYPE.INSCRIPTION
) or anchorId.slotType == GUI_ITEM_TYPE.PROJECTION_DECAL and anchorHelper.descriptor.showOn == ApplyArea.HULL
if needsCorrection:
turretYaw = self.__correctTurretYaw(
anchorHelper, defaultYaw)
anchorHelper = AnchorHelper(anchorHelper.location,
anchorHelper.descriptor,
turretYaw,
anchorHelper.partIdx,
anchorHelper.attachedPartIdx)
self.__updateAnchorHelperWithId(anchorId, anchorHelper)
turretYawLimits = self.__vDesc.gun.turretYawLimits
if turretYawLimits is not None:
turretYaw = math_utils.clamp(turretYawLimits[0],
turretYawLimits[1], turretYaw)
return turretYaw
def getNextYaw(self, currentYaw, targetYaw, delta):
if delta == 0.0 or self.__prevDirection * delta < 0.0:
targetYaw = currentYaw
self.__prevDirection = delta
nextYaw = targetYaw + delta * self.__camSens
if delta > 0.0:
if nextYaw >= currentYaw:
deltaYaw = nextYaw - currentYaw
else:
deltaYaw = 2.0 * math.pi - currentYaw + nextYaw
if deltaYaw > math.pi:
nextYaw = currentYaw + math.pi * 0.9
else:
if nextYaw <= currentYaw:
deltaYaw = currentYaw - nextYaw
else:
deltaYaw = 2.0 * math.pi + currentYaw - nextYaw
if deltaYaw > math.pi:
nextYaw = currentYaw - math.pi * 0.9
if not self.__cycled:
if not self.__reversed:
if delta > 0.0 and (nextYaw > self.__end or nextYaw < currentYaw):
nextYaw = self.__end
elif delta < 0.0 and (nextYaw < self.__start or nextYaw > currentYaw):
nextYaw = self.__start
elif delta > 0.0 and nextYaw > self.__end and nextYaw <= self.__start:
nextYaw = self.__end
elif delta < 0.0 and nextYaw < self.__start and nextYaw >= self.__end:
nextYaw = self.__start
if self.__yawLimits is not None:
if nextYaw < 0.0:
nextYaw += 2.0 * math.pi
nextYaw = math_utils.clamp(self.__yawLimits[0], self.__yawLimits[1], nextYaw)
return nextYaw
def readFloat(dataSec, name, minVal, maxVal, defaultVal):
if dataSec is None:
return defaultVal
else:
value = dataSec.readFloat(name, defaultVal)
value = math_utils.clamp(minVal, maxVal, value)
return value
def getNextGunPitch(self, curAngle, shotAngle, timeDiff, angleLimits):
replayCtrl = BattleReplay.g_replayCtrl
if replayCtrl.isPlaying:
gunPitch = replayCtrl.getGunPitch()
if gunPitch > -100000:
return gunPitch
if self.__maxGunRotationSpeed == 0.0:
shotAngle = curAngle
shotDiff = 0.0
descr = self._avatar.getVehicleDescriptor()
speedLimit = descr.gun.rotationSpeed * timeDiff
else:
if math.fabs(curAngle - shotAngle) < VehicleGunRotator.ANGLE_EPS:
if angleLimits is not None:
return math_utils.clamp(angleLimits[0], angleLimits[1],
shotAngle)
return shotAngle
shotDiff = shotAngle - curAngle
speedLimit = self.__maxGunRotationSpeed * timeDiff
if angleLimits is not None:
if shotAngle < angleLimits[0]:
shotDiff = angleLimits[0] - curAngle
elif shotAngle > angleLimits[1]:
shotDiff = angleLimits[1] - curAngle
staticPitch = self.__getGunStaticPitch()
if staticPitch is not None and shotDiff * (curAngle -
staticPitch) < 0.0:
speedLimit *= 2.0
if staticPitch is not None and self.estimatedTurretRotationTime > 0.0:
idealYawSpeed = abs(shotDiff) / self.estimatedTurretRotationTime
speedLimit = min(speedLimit, idealYawSpeed * timeDiff)
return curAngle + min(
shotDiff, speedLimit) if shotDiff > 0.0 else curAngle + max(
shotDiff, -speedLimit)
def handleMovement(self, dx, dy):
self.__idealTurretYaw, self.__idealGunPitch = self.__worldYawPitchToTurret(
self.__worldYaw, self.__worldPitch)
pitchExcess = self.__calcPitchExcess(self.__idealTurretYaw + dx,
self.__idealGunPitch + dy)
if pitchExcess * dy < 0:
dy = 0
self.__idealTurretYaw, self.__idealGunPitch = self.__clampToLimits(
self.__idealTurretYaw + dx, self.__idealGunPitch + dy)
if pitchExcess != 0.0:
self.__adjustPitchLimitExtension(abs(pitchExcess), True)
currentGunMat = self.__getPlayerGunMat(self.__idealTurretYaw,
self.__idealGunPitch)
self.__worldYaw = currentGunMat.yaw
self.__worldPitch = currentGunMat.pitch
self._matrix.set(currentGunMat)
self.__oscillator.velocity = Vector3(0.0, 0.0, 0.0)
self.__returningOscillator.velocity = Vector3(0.0, 0.0, 0.0)
_, uncompensatedPitch = self._getTurretYawGunPitch(
self.getDesiredShotPoint())
self.__pitchCompensating = math_utils.clamp(
math.radians(-2.0), math.radians(2.0),
self.__idealGunPitch - uncompensatedPitch)
if abs(self.__pitchCompensating) < 1e-06:
self.__pitchCompensating = 0.0
def __init__(self):
ClientSelectableObject.__init__(self)
CallbackDelayer.__init__(self)
TimeDeltaMeter.__init__(self)
self.__state = CameraMovementStates.FROM_OBJECT
self.__camera = cameras.FreeCamera()
self.cameraPitch = math_utils.clamp(-math.pi / 2 * 0.99,
math.pi / 2 * 0.99,
self.cameraPitch)
self.cameraYaw = normalizeAngle(self.cameraYaw)
self.__goalPosition = Math.Vector3(0.0, 0.0, 0.0)
self.__goalDistance = None
self.__goalTarget = Math.Vector3(0.0, 0.0, 0.0)
self.__startPosition = Math.Vector3(0.0, 0.0, 0.0)
self.__startYaw = 0.0
self.__startPitch = 0.0
self.__curTime = None
self.__easedInYaw = 0.0
self.__easedInPitch = 0.0
self.__easeInDuration = 0.0
self.__startFov = None
self.__goalFov = None
if self.enableYawLimits:
self.__yawLimits = Math.Vector2(self.yawLimitMin, self.yawLimitMax)
else:
self.__yawLimits = None
self.__pitchLimits = Math.Vector2(math.degrees(self.pitchLimitMin),
math.degrees(self.pitchLimitMax))
self.__p1 = Math.Vector3(0.0, 0.0, 0.0)
self.__p2 = Math.Vector3(0.0, 0.0, 0.0)
self.__wasPreviousUpdateSkipped = False
return
def __setStartParams(self, params):
a = params.minValue
b = params.maxValue - params.minValue
clampedValue = math_utils.clamp(params.minValue, params.maxValue,
params.startValue)
dArg = -1.0 + (clampedValue - a) * 2.0 / b if b != 0.0 else 0.0
params.startTime = math.asin(dArg)
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 __calculateWorldAimMovement(self, dx, dy):
nextAimRadius = currentAimRadius = math.fabs(self.__cursor.heightAboveBase / math.tan(self.pitch))
if dy != 0:
newPitch = math_utils.clamp(self.__anglesRange[0], -0.001, self.pitch + dy)
nextAimRadius = math.fabs(self.__cursor.heightAboveBase / math.tan(newPitch))
ddx = math.tan(dx) * currentAimRadius
ddy = nextAimRadius - currentAimRadius
return (ddx, ddy)
def __updateSkillDataBlock(self, skillID, level=None):
skillInfo = self.epicMetaGameCtrl.getAllSkillsInformation()[skillID]
currentLvl = self.epicMetaGameCtrl.getSkillLevels().get(skillID, 1)
specLevel = clamp(1, skillInfo.maxLvl, int(level) if level else currentLvl)
bodyBlocks = []
g_battleAbilityTooltipMgr.createBattleAbilityTooltipRenderers(skillInfo, currentLvl, specLevel, bodyBlocks)
bodyBlock = formatters.packBuildUpBlockData(bodyBlocks, gap=15)
self.as_setSkillDataBlockS(bodyBlock)
def __calcPitchExcess(self, turretYaw, gunPitch):
if self.__yawLimits is not None:
turretYaw = math_utils.clamp(self.__yawLimits[0], self.__yawLimits[1], turretYaw)
pitchLimits = calcPitchLimitsFromDesc(turretYaw, self.getPitchLimits(turretYaw))
if pitchLimits[0] > gunPitch:
return pitchLimits[0] - gunPitch
else:
return self.__pitchCompensating + pitchLimits[1] - gunPitch if self.__pitchCompensating + pitchLimits[1] < gunPitch else 0.0
def lookupVerticalFov(horizontalFovValue):
lookupDict = FovExtended.vFovWide if BigWorld.getAspectRatio(
) > FovExtended.arWide else FovExtended.vFovNarrow
if horizontalFovValue not in lookupDict.keys():
horizontalFovValue = (int(horizontalFovValue / 5) + 1) * 5
horizontalFovValue = math_utils.clamp(lookupDict.keys()[0],
lookupDict.keys()[-1],
horizontalFovValue)
return math.radians(lookupDict[horizontalFovValue])
def readVec3(dataSec, name, minVal, maxVal, defaultVal):
if dataSec is None:
return Math.Vector3(defaultVal)
else:
value = dataSec.readVector3(name, Math.Vector3(defaultVal))
for i in xrange(3):
value[i] = math_utils.clamp(minVal[i], maxVal[i], value[i])
return value
