// method: have the audio source play a random footstep audio, plan to vibrate for the footstep based on the vibration settings, and plan to do this again after the duration of that audio has passed // private void playRandomFootstepRecursively() { // determine the footstep audios not played previously (to prevent adjacent repeats in the consecutive randomization), as well as the corresponding sources and indeces // List <AudioClip> footstepAudiosNotPlayedPreviously = new List <AudioClip>(); List <AudioSource> footstepAudiosNotPlayedPreviouslySources = new List <AudioSource>(); List <int> footstepAudiosNotPlayedPreviouslyIndeces = new List <int>(); for (int footstepAudioIndex = 0; footstepAudioIndex < footstepAudios.Length; footstepAudioIndex++) { if (footstepAudioIndex != previousFootstepAudioIndex) { footstepAudiosNotPlayedPreviously.Add(footstepAudios[footstepAudioIndex]); footstepAudiosNotPlayedPreviouslySources.Add(footstepAudioSources[footstepAudioIndex]); footstepAudiosNotPlayedPreviouslyIndeces.Add(footstepAudioIndex); } } // choose a random footstep audio (only out of the footstep audios not played previously); also track its index (out of the entire audios array) // int randomizationIndex = Random.Range(0, footstepAudiosNotPlayedPreviously.Count); // determine the randomization index (out of the audios not played previously) AudioClip randomFootstepAudio = footstepAudiosNotPlayedPreviously[randomizationIndex]; AudioSource randomFootstepAudioSource = footstepAudiosNotPlayedPreviouslySources[randomizationIndex]; int randomFootstepAudioIndex = footstepAudiosNotPlayedPreviouslyIndeces[randomizationIndex]; // track the index of the previously played footstep audio as this one (for next time) // previousFootstepAudioIndex = randomFootstepAudioIndex; // play the random footstep audio // randomFootstepAudioSource.PlayOneShot(randomFootstepAudio); // if vibration is enabled: plan to vibrate for the footstep after the set vibration prewait duration // if (vibrationEnabled) { Invoke("vibrateForFootstep", vibrationPrewait); } // determine the interval duration // float intervalDuration = randomFootstepAudio.length; // initialize the interval duration to the played footstep audio's length as a default float playerSpeed = PlayerVelocityReader.speed(); // determine the player's current speed if (playerSpeed < speedMid) // if the player's current speed below the mid speed reference: interpolate from min to mid { float playerSpeedRangeRatio = ((playerSpeed - speedMin) / (speedMid - speedMin)); intervalDuration = speedIntervalCurve.clamped(intervalMax, intervalMid, playerSpeedRangeRatio); } else // otherwise (if the player's current speed is at or above the mid speed reference): interpolate from mid to max { float playerSpeedRangeRatio = ((playerSpeed - speedMid) / (speedMax - speedMid)); intervalDuration = speedIntervalCurve.clamped(intervalMid, intervalMin, playerSpeedRangeRatio); } // plan to do this again after the determined interval duration has passed // Invoke("playRandomFootstepRecursively", intervalDuration); }
// method: adjust the given audio source's volume by the given amount // protected virtual void adjustVolumeOfGivenAudioSource(AudioSource audioSource, float amount) { // calculate the modified max volume (to use only when the volume is increasing) // float playerSpeedRangeRatio = ((currentPlayerSpeed() - speedMin) / (speedMax - speedMin)); float maxVolumeModified = speedVolumeCurve.clamped(0f, volumeMax, playerSpeedRangeRatio); // adjust the volume to be within the range of 0 to either: the modified max volume, if the amount is positive; the max volume, if the amount is not positive // float maxVolumeToUse = ((amount > 0f) ? maxVolumeModified : volumeMax); audioSource.volume = Mathf.Min(Mathf.Max(0f, (audioSource.volume + amount)), maxVolumeToUse); }
public InterpolationCurve vibrationIntensityCurve = InterpolationCurve.sine; // setting: the curve by which to interpolate the footstep vibration intensity (based on the treading audio volume out of the set max volume) // methods // // method: vibrate for a footstep // private void vibrateForFootstep() { // determine the vibration intensity based on the current volume of the treading audio out of the max volume // float volumeRatio = (treadingAudioSource.volume / volumeMax); ushort vibrationIntensity = (ushort)(vibrationIntensityCurve.clamped(0f, vibrationIntensityMax, volumeRatio)); // if each controller is on, respectively: extendedly vibrate it for the set vibration duration by the determined vibration intensity // if (Controller.left) { Controller.left.vibrateExtended(vibrationDuration, vibrationIntensity); } if (Controller.right) { Controller.right.vibrateExtended(vibrationDuration, vibrationIntensity); } }
// at each update: // private void Update() { // if either: the locomotion dependencies are met, the stuck failsafe dependencies are met: // if (locomotionDependencies.areMet() || dependenciesStuckFailsafe.areMet()) { // if: regular gauge treading is controlled via toggling (instead of holding), regular gauge input just began: invert the tracking of whether the regular treading toggle is on // if (!heldVersusToggled && locomotionInputEnabledAndAllowed() && controller.inputPressing(inputsLocomotion)) { regularTreadingToggle = !regularTreadingToggle; } // if regular gauge treading is not controlled via toggling or locomotion input is not enabled: ensure that the regular gauge treading toggle is off // if (heldVersusToggled || !locomotionInputEnabledAndAllowed()) { regularTreadingToggle = false; } // if this treader is experiencing significant input: // if (experiencingSignificantInput()) { // if a gauge of treading is beginning: broadcast the treading gauge beginning event // if (controller.inputPressing(inputsLocomotion) || controller.inputTouching(inputsLocomotion)) { // broadcast treading gauge beginning event // if (treadingGaugeBeginningEvent != null) { treadingGaugeBeginningEvent(); } } // based on whether any touchpad input is being used: determine the max treading speed // float maxSpeed = 0f; // initialize the max treading speed to 0 if (controller.inputTouched(inputsLocomotion)) // if any touchpad input is being used: set the max treading speed to the corresponding max treading speed gauge: { maxSpeed = ((controller.touchpadPressed || !slowerSpeedEnabled || regularTreadingToggle) ? speedMax : slowerSpeedMax); // if the touchpad is being pressed or the slower guage speed is disabled or regular treading is currently toggled on: use the normal gauge; otherwise (if the touchpad is merely significantly being touched): use the slower gauge } else // otherwise (if no touchpad input is being used): simply set the max treading speed to the normal max treading speed setting { maxSpeed = speedMax; } // initialize the treading velocity (which is just for x and z) as a proportionality (that is, without scaling it to the appropriate magnitude/speed yet) // Vector3 treadingVelocityProportionalityForwardPart = FloatsVector.zeroes; // define the forward part to be the forward direction of this treader Vector3 treadingVelocityProportionalityRightwardPart = FloatsVector.zeroes; // initialize the rightward part as a zeroes vector if (controller.inputTouched(inputsLocomotion)) // if any touchpad input is being used: proportion the velocity parts based on the touchpad input position's coordinates' signage { // proportion the forward part of the velocity based on the touchpad's y (used for z) input position // treadingVelocityProportionalityForwardPart = directionReferenceTransform.forward * controller.touchpadY; // proportion the rightward part of the velocity based on the touchpad's x input position // treadingVelocityProportionalityRightwardPart = directionReferenceTransform.right * controller.touchpadX; } else // otherwise (if no touchpad input is being used): only proportion the treading velocity forward part – using the forward direction of this treader { treadingVelocityProportionalityForwardPart = directionReferenceTransform.forward; } Vector3 treadingVelocity = treadingVelocityProportionalityForwardPart + treadingVelocityProportionalityRightwardPart; // initialize the treading velocity as the sum of both the forward and rightward parts // trim out the y axis of the treading velocity // treadingVelocity = treadingVelocity.withYZero(); // calculate the treading speed // float speed = 0f; // initialize the treading speed to 0 if (controller.inputTouched(inputsLocomotion)) // if any touchpad input is being used: { // set the speed to be the max treading speed, curved by the distance of the input position on the touchpad away from the center, using the curve setting // speed = touchpadSpeedDistanceCurve.clamped(0f, maxSpeed, controller.touchpadDistance); } else // otherwise (if no touchpad input is being used): simply set the treading speed to the max treading speed { speed = speedMax; } // scale the treading velocity to the calculated treading speed // treadingVelocity = treadingVelocity.normalized * speed; // if the player's speed in the direction of the treading velocity is not yet at or past the treading velocity's speed: // if (Vector3.Dot(MoonMotionPlayer.velocity, treadingVelocity.normalized) < speed) { // determine the appropriate responsiveness factor // float appropriateResponsivnessFactor = responsivenessFactorSkiing; if (!Skier.skiing) { bool driftingWithinOneSecondAgo = dependencyDriftingWithinOneSecondAgo.isMet(); if (!driftingWithinOneSecondAgo) { appropriateResponsivnessFactor = responsivenessFactorNonskiingNondrifting; } else { float timeAgoDriftingBoosting = (Time.time - BoostingDriftingTracker.timePlayerWasLastBoostingDrifting); float timeAgoDriftingLaunching = (Time.time - LaunchingDriftingTracker.timePlayerWasLastLaunchingDrifting); float timeAgoDrifting = Mathf.Min(timeAgoDriftingBoosting, timeAgoDriftingLaunching); appropriateResponsivnessFactor = responsivenessFactorNonskiingDriftingCurve.clamped(responsivenessFactorNonskiingDriftingMin, responsivenessFactorNonskiingDriftingMax, (timeAgoDrifting / 1f)); } } // hone the player's velocity x and z axes to the treading velocity x and z axes by the determined treading velocity x and z axes' magnitudes in proportion to the current frame's duration times the appropriate responsivness factor // Vector3 honingVector = treadingVelocity.magnitudes().withYZero() * Time.deltaTime * appropriateResponsivnessFactor; playerRigidbody.velocity = MoonMotionPlayer.velocity.honedTo(treadingVelocity, honingVector); } } // otherwise (if this treader is not currently experiencing significant input): if the player is not currently skiing: // else if (!Skier.skiing) { // determine whether significant input is currently ceasing // bool significantInputCeasing = (locomotionInputEnabledAndAllowed() && (controller.inputUnpressing(inputsLocomotion) || controller.inputUntouching(inputsLocomotion))); // determine whether the other treader is currently experiencing significant input // bool otherTreaderIsCurrentlyExperiencingSignificantInput = (otherTreaderActive() && other.experiencingSignificantInput()); // if: this treader is currently ceasing to experience significant input, the other treader is not currently experiencing significant input // if (significantInputCeasing && !otherTreaderIsCurrentlyExperiencingSignificantInput) { // stop the player's x and z movement (zero the player velocity's x and z axes) // playerRigidbody.velocity = MoonMotionPlayer.velocity.withXAndZZero(); } } } }