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)))