def getMouseIntensity(self, cAngle, mAngle):
if self.__spline is not None and self.__smoothSpline is not None:
if cAngle > mAngle:
return clamp(0.0, self.__smoothSpline.calc(min(cAngle / (0.5 * (mAngle + math.pi)), 1.0)), 1.0)
return clamp(0.0, self.__spline.calc(cAngle / mAngle), 1.0)
else:
return 0.0
return
def currentRadius(self):
player = BigWorld.player()
planeDir = BigWorld.player().getRotation().getAxisZ()
self._Q.fromAngleAxis(self._lastCorrectMaxAngle,
BigWorld.player().getRotation().getAxisX())
Dir = self._Q.rotateVec(planeDir)
reductionPointVector = getReductionPointVector(player.weaponsSettings)
worldPos = Dir * reductionPointVector.length * HUD_REDUCTION_POINT_SCALE + player.position
screenPoint = BigWorld.worldToScreen(worldPos)
screenPoint = Math.Vector3(
clamp(0.0, screenPoint.x, BigWorld.screenWidth()),
clamp(0.0, screenPoint.y, BigWorld.screenHeight()), 1.0)
x = screenPoint.x - 0.5 * BigWorld.screenWidth()
y = -screenPoint.y + 0.5 * BigWorld.screenHeight()
return math.hypot(x, y)
def _update(self):
sniperFov = math.radians(self._camera.context.cameraSettings.defaultFov
) * self._camera.curZoomData.fovPercent
self._model.scopeSize = clamp(
0.0,
float(clientConsts.SNIPER_SCOPE_COEF) *
(1.0 - self._camera.getFOV() / sniperFov), 1.0)
def handleForsage(self, value):
cam = GameEnvironment.getCamera()
cameraState = cam.getState()
signal = self.__forsageValueToSignal(value)
if signal != self.__forsageValue and (
signal == self.PS_NORMAL
or cameraState in self.__class__.__FORSAGE_STATES):
normalizedSpeed = clamp(
0.0,
BigWorld.player().getSpeed() / self.__maxSpeed, 1.0)
if signal == self.PS_FORSAGE:
self.__setCommonGameState(
self.__class__.CommonGameStates.FORSAGE_ACTIVATED)
self.onForsageStarted(normalizedSpeed)
if self.__forsageValue == self.PS_STOP:
self.onBrakingStopped(normalizedSpeed)
elif signal == self.PS_STOP:
self.onBrakingStarted(normalizedSpeed)
if self.__forsageValue == self.PS_FORSAGE:
self.__unsetCommonGameState(
self.__class__.CommonGameStates.FORSAGE_ACTIVATED)
self.onForsageStopped(normalizedSpeed)
elif self.__forsageValue == self.PS_FORSAGE:
self.__unsetCommonGameState(
self.__class__.CommonGameStates.FORSAGE_ACTIVATED)
self.onForsageStopped(normalizedSpeed)
elif self.__forsageValue == self.PS_STOP:
self.onBrakingStopped(normalizedSpeed)
self.__forsageValue = signal
def __init__(self, data=None, scaling=1.0):
self.pos = Math.Vector3()
self.size = Math.Vector3()
self.hasFixedRotation = False
self.rotation = Math.Quaternion(0, 0, 0, 1)
self.absorption = 0.0
self.armorFront = Math.Vector3()
self.armorBack = Math.Vector3()
if data is not None:
self.pos = data.readVector3('position', Math.Vector3())
self.pos *= WORLD_SCALING * scaling
self.size = data.readVector3('size', Math.Vector3())
if self.size.x < 0.0 or self.size.y < 0.0 or self.size.z < 0.0:
LOG_ERROR('BBOX incorrect size', self.size)
self.size *= WORLD_SCALING * 0.5 * scaling
self.rotation = Math.Quaternion(
data.readVector4('rotation', Math.Vector4(0, 0, 0, 1)))
if isZeroQuaternion(self.rotation):
self.rotation = Math.Quaternion(Math.Vector4(0, 0, 0, 1))
self.hasFixedRotation = True
self.absorption = data.readFloat('absorption', DEFAULT_ABSORPTION)
if self.absorption < 0.0 or self.absorption > 1.0:
DBLOG_NOTE('invalid absorption ' + str(self.absorption))
self.absorption = clamp(0.0, self.absorption, 1.0)
if IS_EDITOR:
self.__data = data
self.__scaling = WORLD_SCALING * scaling
return
def __updateCursorPosition(self):
player = BigWorld.player()
reductionPointVector = getReductionPointVector(player.weaponsSettings)
direction = self._cameraStrategy.cursorDirection
if self._backRevert < 0:
p = player.getRotation().getAxisZ()
angle = p.angle(direction)
p *= -1
axis = p.cross(direction)
self._Q.fromAngleAxis(angle, axis)
direction = self._Q.rotateVec(p)
worldPos = direction * reductionPointVector.length * HUD_REDUCTION_POINT_SCALE + player.position
screenPoint = BigWorld.worldToScreen(worldPos)
screenPoint = Math.Vector3(
clamp(0.0, screenPoint.x, BigWorld.screenWidth()),
clamp(0.0, screenPoint.y, BigWorld.screenHeight()), 1.0)
self.mousePosition()
def __updateWindSoundAircraftSpeed(self):
self.__avatarSpeed = self.__avatar.getSpeed()
param = (self.__avatarSpeed - self.__avatarStallSpeed) / (
self.__avatarDiveSpeed - self.__avatarStallSpeed) * 100
RTPC_Wind_Aircraft_Speed = clamp(0, param, 100)
self._soundObject.wwiseGameObject.setRTPC(
WIND_SOUND.RTPC.WIND_AIRCRAFT_SPEED, RTPC_Wind_Aircraft_Speed,
SOUND_CALLBACKS_VCD.PLAYER_GENERAL)
def modYSensOnLowAlt(dy):
from CommonSettings import SensitivityScale_PillowSettings as settings
cfc = 1.0
if dy < 0:
h = BigWorld.player().getAltitudeAboveObstacle() * WORLD_SCALING
cfc = clamp(settings.min_sens,
(h - settings.h1) / (settings.h2 - settings.h1), 1)
return dy * cfc
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 _onGunGroupFire(self, group):
rpm = group.gunDescription.RPM
pulse = 1.0 - clamp(clientConsts.PULSATION_MIN,
rpm / clientConsts.NORMAL_GUNS_RPM,
clientConsts.PULSATION_MAX)
pulseTriggered = (
9999.0 * pulse +
(1.0 if self._pulsationChangeTrigger else 0.0)) / 10000.0
self._model.pulsation = pulseTriggered
self._pulsationChangeTrigger = not self._pulsationChangeTrigger
def getOutNormZone(self, direction, normAngle):
halfNorm = normAngle
norm = 2 * normAngle
ld = self._toSectorLocal(direction)
pitchDir = self._getPitchAngle(ld)
yawDir = self._getYawAngle(ld)
res = Math.Vector2(0, 0)
pB = pitchDir + halfNorm
pD = pitchDir - halfNorm
if pB > self._pitchUp:
res.y = clamp(-1, (pB - self._pitchUp) / norm, 1)
elif pD < self._pitchDown:
res.y = clamp(-1, (pD - self._pitchDown) / norm, 1)
ySign = sign(yawDir)
y = yawDir + ySign * halfNorm
if self._yawRight < y or y < self._yawLeft:
edgeAngle = self._yawRight if ySign >= 0 else self._yawLeft
res.x = -clamp(-1, (y - edgeAngle) / norm, 1)
return res
def __updateWindSoundCriticalLandscape(self):
if not self.__updatePreparations():
return
height = self.__avatar.getAltitudeAboveObstacle()
top = self._windDB.altitudeTop
bottom = self._windDB.altitudeBottom
value = (1 - (height - bottom) / (top - bottom)) * 100
self._soundObject.wwiseGameObject.setRTPC(
WIND_SOUND.RTPC.CRITICAL_LANDSCAPE, clamp(0, value, 100),
SOUND_CALLBACKS_VCD.PLAYER_GENERAL)
def handleSpeed(self, speedMPS, ignoreNonForsageStates=True):
cam = GameEnvironment.getCamera()
cameraState = cam.getState()
isValidCameraState = cameraState in self.__class__.__FORSAGE_STATES if ignoreNonForsageStates else True
if EntityStates.inState(
BigWorld.player(),
EntityStates.GAME | EntityStates.PRE_START_INTRO
) and speedMPS > 0 and isValidCameraState:
speedNorm = clamp(0.0, speedMPS / self.__maxSpeed, 1.0)
self.__speedStateMachine.setTargetSpeed(speedNorm)
def __preprocessShootingParams(self, force, params):
if params:
paramCaliber = 'caliber'
if paramCaliber in params:
curCaliber = params[paramCaliber]
return clamp(
0.0, curCaliber /
self.__class__.__MAX_SHOOTING_FORCE_GUN_CALIBER, 1.0)
LOG_ERROR('Cannot find param: ', paramCaliber)
else:
LOG_ERROR('Param storage is empty')
def __updateWindSoundCriticalManeuvers(self):
if not self.__updatePreparations():
return
avatarWorldVector = self.__avatar.getWorldVector()
avatarAxisZ = self.__avatar.getRotation().getAxisZ()
angle = math.degrees(avatarWorldVector.angle(avatarAxisZ))
top = self._windDB.maneuversAngleTop
bottom = self._windDB.maneuversAngleBottom
value = (angle - bottom) / (top - bottom) * 100
self._soundObject.wwiseGameObject.setRTPC(
WIND_SOUND.RTPC.CRITICAL_MANEUVERS, clamp(0, value, 100))
def _prepareMousePackage(self, direct):
direction = Math.Vector3(direct)
direction.normalise()
planeDir = BigWorld.player().getRotation().getAxisZ()
angle = math.acos(clamp(-1.0, direction.dot(planeDir), 1.0))
correctMaxAngle = self._correctMaxAngle
cfc = self._profile.getMouseIntensity(angle, correctMaxAngle)
direction *= cfc
exAxis = planeDir.cross(direct)
exAxis.normalise()
maxAngle = self._lastCorrectMaxAngle if self._lastCorrectMaxAngle else self._correctMaxAngle
angle = planeDir.angle(direct)
n = clamp(0, angle / maxAngle,
1) * BigWorld.player().maxPitchRotationSpeed * (1.0 - cfc)
exAxis *= n
try:
return (FloatArrayToTupleOfCInt16(direction),
FloatArrayToTupleOfCInt16(exAxis))
except:
print 'trap', direction, exAxis, cfc, angle, correctMaxAngle, n
raise
def processJoystickEvent(self, event):
jSet = InputMapping.g_instance.joystickSettings
if event.axis == jSet.FREE_HORIZONTAL_CAM_GAMEPAD_AXIS and (event.deviceId == jSet.FREE_HORIZONTAL_CAM_GAMEPAD_DEVICE or 0 == jSet.FREE_HORIZONTAL_CAM_GAMEPAD_DEVICE):
hValue = event.value
if abs(hValue) <= jSet.FREE_HORIZONTAL_CAM_GAMEPAD_DEAD_ZONE:
hValue = 0.0
else:
hValue = math.copysign((abs(hValue) - jSet.FREE_HORIZONTAL_CAM_GAMEPAD_DEAD_ZONE) / (1 - jSet.FREE_HORIZONTAL_CAM_GAMEPAD_DEAD_ZONE), hValue)
hValue = self.__signalSmoothing(jSet.FREE_HORIZONTAL_CAM_GAMEPAD_AXIS, hValue, jSet.FREE_HORIZONTAL_CAM_GAMEPAD_SMOOTH_WINDOW)
hValue = self.__signalDiscrete(jSet.FREE_HORIZONTAL_CAM_GAMEPAD_SENSITIVITY, hValue, event.deviceId, event.axis)
self.__axisValue[FREE_HORIZONTAL_CAM] = clamp(-1.0, hValue, 1.0)
self.__setAxisMove()
elif event.axis == jSet.FREE_VERTICAL_CAM_GAMEPAD_AXIS and (event.deviceId == jSet.FREE_VERTICAL_CAM_GAMEPAD_DEVICE or 0 == jSet.FREE_VERTICAL_CAM_GAMEPAD_DEVICE):
vValue = event.value
if abs(vValue) <= jSet.FREE_VERTICAL_CAM_GAMEPAD_DEAD_ZONE:
vValue = 0.0
else:
vValue = math.copysign((abs(vValue) - jSet.FREE_VERTICAL_CAM_GAMEPAD_DEAD_ZONE) / (1 - jSet.FREE_VERTICAL_CAM_GAMEPAD_DEAD_ZONE), vValue)
vValue = self.__signalSmoothing(jSet.FREE_VERTICAL_CAM_GAMEPAD_AXIS, vValue, jSet.FREE_VERTICAL_CAM_GAMEPAD_SMOOTH_WINDOW)
vValue = self.__signalDiscrete(jSet.FREE_VERTICAL_CAM_GAMEPAD_SENSITIVITY, vValue, event.deviceId, event.axis)
vValue = vValue if jSet.INVERT_FREE_VERTICAL_CAM_GAMEPAD else -vValue
self.__axisValue[FREE_VERTICAL_CAM] = clamp(-1.0, vValue, 1.0)
self.__setAxisMove()
def calculateBulletDamage(shooter, victim, gd, v0, shootInfo,
distEffectiveness):
k = max(0.0, v0 * distEffectiveness / (gd.bulletSpeed / WORLD_SCALING))
damage = k * shootInfo.kineticPartMinDist * gd.DPS * 60.0 / gd.RPM
distVector = victim.position - shooter.position
v1 = getEntityVector(shooter)
v2 = getEntityVector(victim)
distLen = distVector.length
vProjectionLen = 0 if distLen == 0 else (v1 -
v2).dot(distVector) / distLen
vSum = (Weapons.getEntityNominalSpeed(shooter) +
Weapons.getEntityNominalSpeed(victim)) * WORLD_SCALING
famK = 1.0 if vSum == 0.0 else FAM_PIVOT + (
FAM_SPEED_ETALON_MULT - FAM_PIVOT) * vProjectionLen / vSum
return damage * clamp(FAM_CLAMP_MIN, famK, FAM_CLAMP_MAX)
def update(self, speedValue):
stateChanged = False
if speedValue > self.__endValue:
stateChanged = self.goNextState()
elif speedValue < self.__startValue:
stateChanged = self.goPrevState()
if self.isActive and not stateChanged:
finalSpeedValue = clamp(self.__startValue, speedValue,
self.__endValue)
finalSpeedValue = (finalSpeedValue - self.__startValue) / (
self.__endValue - self.__startValue)
res = self.__setEffectTime(self.__effectID, finalSpeedValue)
if not res:
g_instance.onCameraEffect(self.__effectID, True)
self.__setEffectTime(self.__effectID, finalSpeedValue)
def _onSaveControls(self):
self.__isSlipComp = InputMapping.g_instance.mouseSettings.SLIP_COMPENSATION
BigWorld.player().cell.sendLiningFlag(
clamp(0, self.__isSlipComp * 255, 255))
settings = InputMapping.g_instance.mouseSettings
camera = GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyNormal']
cameraInertia = settings.INERTIA_CAMERA
camera.speedRoll = CAMERA_ROLL_SPEED
camera.speedYaw = CAMERA_YAW_SPEED + 2.0 * CAMERA_YAW_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
camera.speedPitch = CAMERA_PITCH_SPEED + 2.0 * CAMERA_PITCH_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
if InputMapping.g_instance.primarySettings.INVERT_VERT:
self.__keyboard.verticalSign(1.0)
else:
self.__keyboard.verticalSign(-1.0)
def __updateCameraSpeed(self):
cameraSpeed = 0
speed = math.degrees(
self.__cameraInfo.direction.angle(
self.__cameraInfo.camera.direction)
) / RTPC_Wind_Update_Interval
top = self._windDB.cameraSpeedTop
bottom = self._windDB.cameraSpeedBottom
if bottom < speed:
self.__cameraInfo.ticksCounter += 1
else:
self.__cameraInfo.ticksCounter = 0
if self.__cameraInfo.ticksDelay <= self.__cameraInfo.ticksCounter:
value = (speed - bottom) / (top - bottom) * 100
cameraSpeed = clamp(0, value, 100)
self.__cameraInfo.direction = self.__cameraInfo.camera.direction
self._soundObject.wwiseGameObject.setRTPC(
WIND_SOUND.RTPC.CRITICAL_CAMERA_SPEED, cameraSpeed)
def __setFovByDistance(self, distance, rampTime):
settings = self._context.cameraSettings
distMin = settings.cam_dist_constr[0]
distMed = settings.cam_dist_constr[1]
distMax = settings.cam_dist_constr[2]
distanceK = clamp(distMin, distance, distMax)
newFov = 0
if distanceK < distMed:
k = (distMed - distanceK) / (distMed - distMin) if distMed != distMin else 0
fovDelta = settings.cam_fov_constr[0] - settings.cam_fov_constr[1]
newFov = fovDelta * k + settings.cam_fov_constr[1]
else:
k = (distanceK - distMed) / (distMax - distMed) if distMed != distMax else 0
fovDelta = settings.cam_fov_constr[2] - settings.cam_fov_constr[1]
newFov = fovDelta * k + settings.cam_fov_constr[1]
if self.__scheduledFov != newFov:
self.__scheduledFov = newFov
BigWorld.projection().rampFov(newFov, rampTime, 1.0)
def updateSize(self, fov, size):
self.__valuesQueue[self.__valuesQueueIndex] = size
self.__valuesQueueIndex = (self.__valuesQueueIndex + 1) % 10
newValue = sum(self.__valuesQueue) / 10
if newValue != 0:
newValue += self.__minTargetSize
deltaValue = newValue - self.__prevValue
if newValue != self.__targetValue:
self.__targetValue = newValue
self.__smoothStep = deltaValue / 10
if self.__prevValue != newValue or self.__prevFov != fov or self.__prevActive != self.__active:
if abs(deltaValue) > 0.0001:
newValue = self.__prevValue + self.__smoothStep
self.__prevValue = newValue
self.__prevFov = fov
self.__prevActive = self.__active
if GameEnvironment.g_instance:
value = clamp(self.__clampMinTargetSize,
TARGET_DISP_IDENTITY_CFC * newValue,
self.__clampMaxTargetSize)
GameEnvironment.g_instance.eOnCrossSizeChanged(
value / fov * 2.0 * BigWorld.screenHeight())
def _onSaveControls(self):
settings = InputMapping.g_instance.mouseSettings
camera = GameEnvironment.getCamera(
).getDefualtStrategies['CameraStrategyNormal']
cameraInertia = settings.INERTIA_CAMERA
cameraInertiaRoll = settings.INERTIA_CAMERA_ROLL
camera.speedRoll = CAMERA_ROLL_SPEED + 2.0 * CAMERA_ROLL_SPEED * (
1.0 - cameraInertiaRoll) if cameraInertiaRoll > 0 else 100
camera.speedYaw = CAMERA_YAW_SPEED + 2.0 * CAMERA_YAW_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
camera.speedPitch = CAMERA_PITCH_SPEED + 2.0 * CAMERA_PITCH_SPEED * (
1.0 - cameraInertia) if cameraInertia > 0 else 100
flex = lambda x, min_, max_: (max_ - min_) * math.pow(
x, 2.0) * math.exp(x - 1) + min_
self.__overlookCameraInput.setTurnSpeed(
flex(settings.HATKA_MOVE_SPEED, 100, 400))
camera.flexibility = flex(1.0 - settings.HATKA_MOVE_SPEED, 1e-15,
0.0001)
self._isSlipComp = settings.SLIP_COMPENSATION_VALUE
BigWorld.player().cell.sendLiningFlag(
int(clamp(0.0, settings.SLIP_COMPENSATION_VALUE * 255, 255)))
BigWorld.player().cell.sendJoyVersionFlag(
settings.JOY_VERSION_SWITCHER)
self.__joystick.pushLastEvent()
def slipCompensationVisualisation(self):
if self._isSlipComp and not self._notControlledByUser:
owner = BigWorld.player()
fmRotation = owner.getRotation()
speedDirection = owner.getWorldVector()
speedDirection.normalise()
dotX = clamp(-1.0, fmRotation.getAxisX().dot(speedDirection), 1.0)
dotY = clamp(-1.0, fmRotation.getAxisY().dot(speedDirection), 1.0)
angleX = abs(math.pi / 2.0 - math.acos(dotX)) / math.radians(10.0)
angleY = abs(math.pi / 2.0 - math.acos(dotY)) / math.radians(
35.0 / 2.0)
signX = sign(dotX)
signY = sign(dotY)
hAxis = clamp(
-1.0, self.__lastAxis[HORIZONTAL_AXIS] - self._isSlipComp *
(1.0 - abs(self.__lastAxis[HORIZONTAL_AXIS])) *
clamp(-1.0, signX * angleX, 1.0), 1.0)
owner.applyInputAxis(HORIZONTAL_AXIS, hAxis)
vAxis = clamp(
-1.0, self.__lastAxis[VERTICAL_AXIS] - self._isSlipComp *
(1.0 - abs(self.__lastAxis[VERTICAL_AXIS])) *
clamp(-1.0, signY * angleY, 1.0), 1.0)
owner.applyInputAxis(VERTICAL_AXIS, vAxis)
def _onTurretChanged(self, aimType, RPM):
self._model.crossImage = AimingTypes.get(aimType, AimingTypes[0])
self._model.rpm = RPM
mul = 1.0 - clamp(clientConsts.PULSATION_MIN, RPM / clientConsts.NORMAL_GUNS_RPM, clientConsts.PULSATION_MAX)
self._model.pulsStrength = clientConsts.MAX_PULSATION_LENGTH * mul
def createWorldEffect(self,
effectID,
worldPos,
properties,
wasDelayed=False):
effectDB = db.DBLogic.g_instance.getEffectDataVariant(
effectID, properties.get('variant', 'OWN'))
if effectDB is None:
return ()
else:
count = int(effectDB.get('drawChance', 0))
if count and count < randint(1, 100):
return ()
count = int(effectDB.get('maxCount', 0))
if count:
if effectID in self.__particleCount:
if self.__particleCount[effectID] > randint(1, int(count)):
return ()
self.__particleCount[effectID] += 1
else:
self.__particleCount[effectID] = 1
if worldPos is None:
LOG_ERROR('Particle position is not Vector3 or tuple of 3')
worldPos = Math.Vector3()
if len(properties) > 0:
effectProps = effectDB.copy()
effectProps.update(properties)
else:
effectProps = effectDB
attachData = {
'type': effectDB.get('attachType', 'world'),
'position': worldPos
}
if 'rotation' in properties:
attachData['rotation'] = properties['rotation']
if 'attachType' in properties:
attachData['type'] = properties['attachType']
if effectID in self.__particleCache and len(
self.__particleCache[effectID]) > 0:
effect = self.__particleCache[effectID].pop()
effect.attachProperties = attachData
effect.properties = effectProps
if isinstance(effect, EffectTimedParticle):
effect.clearPixie()
effect.attach()
else:
effect = self.__createEffect(effectDB['type'], effectProps,
attachData)
effect.effectID = effectID
effects = [effect]
if 'decal' in effectProps:
decalData = effectProps['decal']
decalTextureId = BigWorld.deferredImpactTextureIndex(
decalData['texture'])
if decalTextureId >= 0:
pos = Math.Vector3(worldPos)
decalStartRay = (pos[0], pos[1] + EFFECT_COLLISION_RANGE,
pos[2])
decalEndRay = (pos[0], pos[1] - EFFECT_COLLISION_RANGE,
pos[2])
BigWorld.addDeferredImpact(decalStartRay, decalEndRay,
decalData['size'],
decalTextureId)
if 'blastForce' in effectProps:
player = BigWorld.player()
effectVec = worldPos - player.position
effectBlastForce = effectProps['blastForce']
if effectBlastForce > BLAST_FORCE_MAX:
effectBlastForce = clamp(0.0, effectBlastForce,
BLAST_FORCE_MAX)
force = (effectBlastForce - BLAST_FORCE_DISTANCE_FACTOR *
(effectVec.length / WORLD_SCALING)) / BLAST_FORCE_MAX
if CameraEffect.g_instance and force > 0 and not IS_EDITOR:
CameraEffect.g_instance.onCameraEffect(
'NEAR_EXPLOSION', True, force, effectVec)
self.showScreenParticle('screen_expl_dirt')
if 'screenEffectID' in effectProps and not IS_EDITOR:
self.setScreenParticle(effectProps['screenEffectID'], worldPos)
if 'effectSet' in effectProps:
if 'selectOne' in effectProps and effectProps['selectOne']:
effects += self.createWorldEffect(
choice(effectProps['effectSet']), worldPos, properties)
else:
for addEffect in effectProps['effectSet']:
effects += self.createWorldEffect(
addEffect, worldPos, properties)
return effects
def __updateVisibleAxis(self):
if not self._notControlledByUser and EntityStates.inState(BigWorld.player(), EntityStates.GAME):
player = BigWorld.player()
fmRotation = BigWorld.player().getRotation()
norm = Math.Vector3(self.__camDirection)
norm.normalise()
yawAngle = 0.5 * math.pi - math.acos(clamp(-1.0, fmRotation.getAxisX().dot(norm), 1.0))
pitchAngle = 0.5 * math.pi - math.acos(clamp(-1.0, fmRotation.getAxisY().dot(norm), 1.0))
mouseRoll = -sign(yawAngle) * clamp(-1.0, max(0.0, abs(yawAngle) / math.radians(5.0) - 1.0), 1.0)
hAxis = clamp(-1.0, yawAngle / math.radians(5.0) * 8.0, 1.0) * (1 - abs(self.__lastKeyBoardAxis[HORIZONTAL_AXIS])) + self.__lastKeyBoardAxis[HORIZONTAL_AXIS]
vAxis = clamp(-1.0, pitchAngle / math.radians(10.0), 1.0) * (1 - abs(self.__lastKeyBoardAxis[VERTICAL_AXIS])) + self.__lastKeyBoardAxis[VERTICAL_AXIS]
rAxis = bool(InputMapping.g_instance.mouseSettings.ROLL_SPEED_CFC) * mouseRoll * (1 - abs(self.__lastKeyBoardAxis[ROLL_AXIS])) + self.__lastKeyBoardAxis[ROLL_AXIS]
speedDirection = player.getWorldVector()
speedDirection.normalise()
dotX = clamp(-1.0, fmRotation.getAxisX().dot(speedDirection), 1.0)
dotY = clamp(-1.0, fmRotation.getAxisY().dot(speedDirection), 1.0)
angleX = abs(0.5 * math.pi - math.acos(dotX)) / math.radians(10.0)
angleY = abs(0.5 * math.pi - math.acos(dotY)) / math.radians(35.0 / 2.0)
signX = sign(dotX)
signY = sign(dotY)
hAxis = clamp(-1.0, hAxis - (1.0 - abs(hAxis)) * clamp(-1.0, signX * angleX, 1.0), 1.0)
vAxis = clamp(-1.0, vAxis - (1.0 - abs(vAxis)) * clamp(-1.0, signY * angleY, 1.0), 1.0)
mouseAngle = math.acos(clamp(-1.0, fmRotation.getAxisZ().dot(norm), 1.0))
equalizerAngle = 0.5 * (0.3 + 0.7 * InputMapping.g_instance.mouseSettings.RADIUS_OF_CONDUCTING) * BigWorld.projection().fov * InputMapping.g_instance.mouseSettings.EQUALIZER_ZONE_SIZE
equalizer = max(0.0, (equalizerAngle - mouseAngle) / equalizerAngle) * clamp(-1.0, 3.0 * bool(InputMapping.g_instance.mouseSettings.EQUALIZER_FORCE) * player.roll / math.pi, 1.0) if equalizerAngle else 0.0
rAxis = clamp(-1.0, rAxis - (1.0 - abs(rAxis)) * equalizer, 1.0)
self.__applyInputAxis(HORIZONTAL_AXIS, clamp(-1.0, hAxis, 1.0))
self.__applyInputAxis(ROLL_AXIS, clamp(-1.0, rAxis, 1.0))
self.__applyInputAxis(VERTICAL_AXIS, clamp(-1.0, vAxis, 1.0))
self.__applyInputAxis(FORCE_AXIS, self.__lastKeyBoardAxis[FORCE_AXIS])
automaticFlaps = False
if InputMapping.g_instance.mouseSettings.AUTOMATIC_FLAPS:
automaticFlaps = int(max(0.0, player.asymptoteVMaxPitch - abs(player.getRotationSpeed().y)) < 0.25 * player.asymptoteVMaxPitch)
self.__applyInputAxis(FLAPS_AXIS, self.__lastKeyBoardAxis[FLAPS_AXIS] or automaticFlaps)
def calcInterpolation(self, minValue, maxValue, t, d):
t = clamp(0.0, t / d, 1.0)
return minValue + (maxValue - minValue) * self._curve.calc(t)
def Angle(a, b):
if a.length == 0 or b.length == 0:
return 0
angle = a.dot(b) / (a.length * b.length)
return abs(math.acos(clamp(-1, angle, 1)))
