Feel

https://feel-docs.moremountains.com
Admin
Feel is a modular Unity asset that provides ready-to-use game feel solutions including screenshakes,...
Tokens:36,611
Snippets:508
Trust Score:7.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Full Spring Implementation Example

Source: https://feel-docs.moremountains.com/springs.html

A complete example demonstrating an image following the mouse position using a bouncy spring.

```csharp
using UnityEngine;
using MoreMountains.Feedbacks;

public class Test : MonoBehaviour
{
	public MMSpringVector2 _vector2Spring;
	private RectTransform _rectTransform;
	private Vector2 _mouseLocalPoint;

	void Start()
	{
		_rectTransform = GetComponent<RectTransform>();
	}

	void Update()
	{
		// we compute the place where we want our image to move to, based on the position of the mouse
		RectTransformUtility.ScreenPointToLocalPointInRectangle(_rectTransform.parent as RectTransform,
		Input.mousePosition, null, out _mouseLocalPoint);

		// we tell our spring to move to that value
		_vector2Spring.MoveTo(_mouseLocalPoint);

		// we update our spring
		_vector2Spring.UpdateSpringValue(Time.deltaTime);

		// we apply the spring's current value to our image's position
		_rectTransform.anchoredPosition = _vector2Spring.CurrentValue;
	}
}
```

--------------------------------

### Implementing a Custom Feedback with MMF_FeedbackBase

Source: https://feel-docs.moremountains.com/creating_mmfeedbacks.html

This example demonstrates how to extend MMF_FeedbackBase to control a CanvasGroup's opacity. It includes property definitions, inspector setup, and the required FillTargets method implementation.

```csharp
using MoreMountains.Tools;
using UnityEngine;
using UnityEngine.Scripting.APIUpdating;

namespace MoreMountains.Feedbacks
{
  /// <summary>
  /// This feedback lets you control the opacity of a canvas group over time
  /// </summary>
  [AddComponentMenu("")]
  [FeedbackHelp("This feedback lets you control the opacity of a canvas group over time.")]
  [MovedFrom(false, null, "MoreMountains.Feedbacks.MMTools")]
  [FeedbackPath("UI/CanvasGroup")]
  public class MMF_CanvasGroup : MMF_FeedbackBase
  {
    /// sets the inspector color for this feedback
    #if UNITY_EDITOR
    public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.UIColor; } }
    public override bool EvaluateRequiresSetup() { return (TargetCanvasGroup == null); }
    public override string RequiredTargetText { get { return TargetCanvasGroup != null ? TargetCanvasGroup.name : "";  } }
    public override string RequiresSetupText { get { return "This feedback requires that a TargetCanvasGroup be set to be able to work properly. You can set one below."; } }
    #endif
    public override bool HasAutomatedTargetAcquisition => true;
    protected override void AutomateTargetAcquisition() => TargetCanvasGroup = FindAutomatedTarget<CanvasGroup>();

    // below we declare a number of properties that are specific to our use case
    // for each value you'll want to have a MMTweenType curve to move over,
    // a target, remap zero and one values, and a value to apply on instant

    [MMFInspectorGroup("Canvas Group", true, 12, true)]
    /// the receiver to write the level to
    [Tooltip("the receiver to write the level to")]
    public CanvasGroup TargetCanvasGroup;
    /// the curve to tween the opacity on
    [Tooltip("the curve to tween the opacity on")]
    [MMFEnumCondition("Mode", (int)MMFeedbackBase.Modes.OverTime)]
    public MMTweenType AlphaCurve = new MMTweenType(new AnimationCurve(new Keyframe(0, 0), new Keyframe(0.3f, 1f), new Keyframe(1, 0)));
    /// the value to remap the opacity curve's 0 to
    [Tooltip("the value to remap the opacity curve's 0 to")]
    [MMFEnumCondition("Mode", (int)MMFeedbackBase.Modes.OverTime)]
    public float RemapZero = 0f;
    /// the value to remap the opacity curve's 1 to
    [Tooltip("the value to remap the opacity curve's 1 to")]
    [MMFEnumCondition("Mode", (int)MMFeedbackBase.Modes.OverTime)]
    public float RemapOne = 1f;
    /// the value to move the opacity to in instant mode
    [Tooltip("the value to move the opacity to in instant mode")]
    [MMFEnumCondition("Mode", (int)MMFeedbackBase.Modes.Instant)]
    public float InstantAlpha;

    public override void OnAddFeedback()
    {
      base.OnAddFeedback();
      RelativeValues = false;
    }

    // this method is where the magic happens.
    // we create a base target and a receiver. We bind our receiver's object
    // and specify what property we want to impact on it
    // then we setup our MMF_FeedbackBaseTarget, and finally we add it to our list of targets. That's all!
    protected override void FillTargets()
    {
    	if (TargetCanvasGroup == null)
      {
        return;
      }
    	MMF_FeedbackBaseTarget target = new MMF_FeedbackBaseTarget();
    	MMPropertyReceiver receiver = new MMPropertyReceiver();
    	receiver.TargetObject = TargetCanvasGroup.gameObject;
    	receiver.TargetComponent = TargetCanvasGroup;
    	receiver.TargetPropertyName = "alpha";
    	receiver.RelativeValue = RelativeValues;
    	target.Target = receiver;
    	target.LevelCurve = AlphaCurve;
    	target.RemapLevelZero = RemapZero;
    	target.RemapLevelOne = RemapOne;
    	target.InstantLevel = InstantAlpha;
    	_targets.Add(target);
    }
  }
}
```

--------------------------------

### Implement editor overrides

Source: https://feel-docs.moremountains.com/mmf-player.html

Define setup requirements, warning messages, and header information for custom feedbacks in the inspector.

```csharp
// if your feedback requires some form of setup, and you'd like to display a warning if that requirement isn't met,
// you can override EvaluateRequiresSetup to have it return such a condition
public override bool EvaluateRequiresSetup() { return (MyTargetObject == null); }

// if you define a required setup like on the line above, you'll want to override the RequiresSetupText property,
// to specify what text should appear in the warning message in the inspector
public override string RequiresSetupText => "This feedback requires that you set a MyTargetObject into its slot below.";

// if you want to display some extra info in the right part of your feedback's header,
// you can do so with the property below. Here we want to display the name of
// our MyTargetObject, so we check it's not null and return that.
// But it could be any other value you prefer.
public override string RequiredTargetText => MyTargetObject != null ? MyTargetObject.name : "";
```

--------------------------------

### Declare an MMF Player reference

Source: https://feel-docs.moremountains.com/mmf-player.html

Example declaration of an MMF_Player reference for use in runtime manipulation scripts.

```csharp
public MMF_Player MyTargetMMFPlayer;
```

--------------------------------

### Triggering Shaker and Fader Events

Source: https://feel-docs.moremountains.com/tweens-events.html

Examples of triggering camera shakes, screen fades, and audio filter shakes via global events.

```csharp
// triggering a simple camera shake, this event will be processed by a MMCameraShaker or MMCinemachineCameraShaker
MMCameraShakeEvent.Trigger(duration: 1f, amplitude: 5f, frequency: 20f, amplitudeX: 5f, amplitudeY: 5f, amplitudeZ: 5f, infinite: false, channelData: new MMChannelData(MMChannelModes.Int, 0, null), false) ;

// triggers a fade out over 0.5s and an ease-in overhead curve, this event will be processed by a MMFader
MMFadeEvent.Trigger(0.5f, 0f, MMTween.MMTweenCurve.EaseInOverhead, 0, false, Vector3.zero);

// triggers a reverb shake event, shaking the value of the reverb from 0 to 1 over half a second, along a specified animation curve
MMAudioFilterReverbShakeEvent.Trigger(someAnimationCurve, 0.5f, 0f, 1f);
```

--------------------------------

### Implement Real-time Haptic Modulation

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Examples of updating haptic parameters based on user input, such as a knob interaction.

```C#
protected virtual void HandlePower()
{
   _knobValue = Knob.Active ? Knob.Value : 0f;
   if (!_carStarted)
   {
      ...
      HapticPatterns.PlayConstant(_knobValue, _knobValue, MaximumPowerDuration);
      CarEngineAudioSource.Play();
      ...
   }
   ...
}
```

```C#
if (_knobValue > MinimumKnobValue)
{
   Power -= Time.deltaTime;
   Power = Mathf.Clamp(Power, 0f, MaximumPowerDuration);

   HapticController.clipLevel = _knobValue;
   HapticController.clipFrequencyShift = _knobValue;
   ...
}
```

```C#
HapticPatterns.PlayConstant(_knobValue, _knobValue,
MaximumPowerDuration);

CarEngineAudioSource.Play();
```

```C#
HapticController.Play(carEngineHaptic); //carEngineHaptic is defined as HapticClip carEngineHaptic

HapticController.clipLevel = _knobValue;
HapticController.clipFrequencyShift = _knobValue;

CarEngineAudioSource.Play();
```

--------------------------------

### Triggering Sound Manager Events

Source: https://feel-docs.moremountains.com/tweens-events.html

Example of pausing a specific sound track using the MMSoundManager event system.

```csharp
MMSoundManagerTrackEvent.Trigger(MMSoundManagerTrackEventTypes.PauseTrack,MMSoundManager.MMSoundManagerTracks.UI);
```

--------------------------------

### Accessing MMAudioAnalyzer values via script

Source: https://feel-docs.moremountains.com/mmaudioanalyzer.html

Demonstrates how to use normalized buffered amplitude to drive light intensity and how to access specific beat values.

```csharp
TargetLight.intensity = TargetAnalyzer.NormalizedBufferedAmplitude * 5f;
```

```csharp
TargetAnalyzer.Beats[0].CurrentValue
```

--------------------------------

### GettingStartedTutorialHero Script

Source: https://feel-docs.moremountains.com/getting-started.html

A simple MonoBehaviour class that handles character jumping via Rigidbody physics and triggers MMF_Player feedback components.

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using MoreMountains.Feedbacks;
using UnityEngine.Events;

/// <summary>
/// A very simple class used to make a character jump, designed to be used in Feel's Getting Started tutorial
/// </summary>
public class GettingStartedTutorialHero : MonoBehaviour
{
    [Header("Hero Settings")]
    /// a key the Player has to press to make our Hero jump
    public KeyCode ActionKey = KeyCode.Space;
    /// the force to apply vertically to the Hero's rigidbody to make it jump up
    public float JumpForce = 8f;

    [Header("Feedbacks")]
    /// a MMF_Player to play when the Hero starts jumping
    public MMF_Player JumpFeedback;
    /// a MMF_Player to play when the Hero lands after a jump
    public MMF_Player LandingFeedback;

    private const float _lowVelocity = 0.1f;
    private Rigidbody _rigidbody;
    private float _velocityLastFrame;
    private bool _jumping = false;

    /// <summary>
    /// On Awake we store our Rigidbody and force gravity to -30 on the y axis so that jumps feel better
    /// </summary>
    private void Awake()
    {
        _rigidbody = this.gameObject.GetComponent<Rigidbody>();
        Physics.gravity = Vector3.down * 30;
    }

    /// <summary>
    /// Every frame
    /// </summary>
    private void Update()
    {
        // we check if the Player has pressed our action key, and trigger a jump if that's the case
        if (Input.GetKeyDown(ActionKey) && !_jumping)
        {
            Jump();
        }

        // if we're jumping, were going down last frame, and have now reached an almost null velocity
        if (_jumping && (_velocityLastFrame < 0) && (Mathf.Abs(_rigidbody.velocity.y) < _lowVelocity))
        {
            // then we just landed, we reset our state
            _jumping = false;
        }

        // we store our velocity
        _velocityLastFrame = _rigidbody.velocity.y;
    }

    /// <summary>
    /// Makes our hero jump in the air
    /// </summary>
    private void Jump()
    {
        _rigidbody.AddForce(Vector3.up * JumpForce, ForceMode.Impulse);
        _jumping = true;
    }
}
```

--------------------------------

### Checking Basic Haptic Support

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Verify if the device supports basic haptic playback.

```csharp
bool hapticsSupported = DeviceCapabilities.isVersionSupported;
```

--------------------------------

### Control MMF_Player via C#

Source: https://feel-docs.moremountains.com/core-concepts.html

Basic methods for initializing, playing, stopping, and resetting feedback sequences in Unity.

```csharp
using UnityEngine;
using MoreMountains.Feedbacks;

public class Test : MonoBehaviour
{
	// declares a player, that you can then set via your component's inspector
	// note that here we're using the "new" MMF Player class, which is the recommended option from now on
	public MMF_Player MyPlayer;

	private void Something()
	{
		// initializes the player and all its feedbacks,
		// making sure everything's correctly setup before playing it
		// will run on its own on Start by default, call it after your runtime changes if you make any
		MyPlayer.Initialization();
		// asks the player to play its sequence of feedbacks
		MyPlayer.PlayFeedbacks();
		// asks the player to play its sequence of feedbacks,
		// passing a position and intensity to feedbacks that may use it
		Vector3 myPosition = new Vector3(1f,2f,0f);
		float myIntensity = 1f;
		MyPlayer.PlayFeedbacks(myPosition, myIntensity);
		// stops the player, preventing all further feedbacks in the sequence from playing
		MyPlayer.StopFeedbacks();
		// skips the sequence to its end, putting all feedback targets in their final state
		// note that this can take up to 3 frames to complete, 
        // and requires the MMF Player to be playing first
		MyPlayer.SkipToTheEnd();
		// the opposite of SkipToTheEnd, ForceInitialValues lets you force the feedbacks
		// that support it to put themselves at the start of their transitions
		// this is a legacy method, which plays and instantly stops the feedbacks
		// and in most cases you'll probably want to use RestoreInitialValues instead
		MyPlayer.ForceInitialValues();
		// reverts all targets to their initial values, comes with a dedicated implementation per feedback
		MyPlayer.RestoreInitialValues();		
	}
}
```

--------------------------------

### Trigger HapticSource via Script

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Demonstrates triggering a HapticSource alongside an AudioSource to maintain synchronization.

```csharp
...
public virtual void OnPointerExit(PointerEventData data)
{
   ...
   SpringAudioSource.Play();
   SpringHapticSource.Play();
}
...
public virtual void SetPitch(float newPitch)
{
   SpringAudioSource.pitch = newPitch;
   SpringHapticSource.frequencyShift = NiceVibrationsDemoHelpers.Remap(newPitch, 0.3f, 1f, -1.0f, 1.0f);
}
```

--------------------------------

### Configuring Haptic Fallbacks

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Set a fallback preset to be used automatically if the device cannot play a specific haptic clip.

```csharp
HapticController.fallbackPreset = HapticPatterns.PresetType.Selection;
HapticController.Play(jumpClip);
```

--------------------------------

### Reinitialize Feedback

Source: https://feel-docs.moremountains.com/mmf-player.html

Call Initialization after modifying cached settings to ensure changes are applied before playing the MMF Player.

```csharp
// we get our Animation Crossfade feedback on our MMF Player and change its state name
MMF_AnimationCrossfade crossfadeFeedback = MyTargetMMFPlayer.GetFeedbackOfType<MMF_AnimationCrossfade>();
crossfadeFeedback.StateName = "SomeNewState";
// we initialize our MMF Player
MyTargetMMFPlayer.Initialization();
// and we play it
MyTargetMMFPlayer.PlayFeedbacks();
```

--------------------------------

### Importing Nice Vibrations Namespace

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Include this namespace at the top of any script that utilizes Nice Vibrations methods.

```csharp
using Lofelt.NiceVibrations;
```

--------------------------------

### Create a Finite State Machine

Source: https://feel-docs.moremountains.com/mmstatemachine.html

Defines a character controller that uses MMStateMachine to manage movement states like Idle, Walking, or Jumping.

```csharp
using MoreMountains.Tools;
using UnityEngine;

/// a demo class of a very basic character controller. It reads input and updates a state machine.
public class MyCharacter : MonoBehaviour
{
    /// we declare all the possible states for our finite state machine
    public enum MovementStates { Null, Idle, Walking, Running, Dashing, Jumping }
    /// we declare our state machine, and specify it'll work on MovementStates
    public MMStateMachine<MovementStates> MovementState;

    /// on Awake we initialize our state machine
    private void Awake()
    {
        MovementState = new MMStateMachine<MovementStates>(this.gameObject, true);
    }

    /// on Update we look for input and trigger our character controller's methods accordingly
    /// each of these methods change the current state of our character on our state machine
    /// In a real controller they would also apply forces, move our character around, change its speed, etc
    private void Update()
    {
        if (Input.GetKeyDown("space"))
        {
            Jump();
        }
        if (Input.GetKeyDown("d"))
        {
            Dash();
        }
        if (Input.GetKeyDown("r"))
        {
            Run();
        }

        // we also output the current state to our on-screen debug console
        MMDebug.DebugOnScreen("Current Character State", MovementState.CurrentState);
    }

    private void Jump()
    {
        MovementState.ChangeState(MovementStates.Jumping);
    }

    private void Dash()
    {
        MovementState.ChangeState(MovementStates.Dashing);
    }

    private void Run()
    {
        MovementState.ChangeState(MovementStates.Running);
    }
}
```

--------------------------------

### Play a sound with advanced options

Source: https://feel-docs.moremountains.com/mmsoundmanager.html

Configures playback behavior using an MMSoundManagerPlayOptions struct before triggering the event.

```csharp
// we create a new options struct
MMSoundManagerPlayOptions options;
// we initialize it with the default values
options = MMSoundManagerPlayOptions.Default;
// we override a few options
options.Volume = 0.5f;
options.Priority = 200;
options.Loop = true;
// we call our event, pass it our options, our sound plays
MMSoundManagerSoundPlayEvent.Trigger(sfx, options);
```

--------------------------------

### Checking Real-time Modulation Support

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Verify if the device supports runtime amplitude or frequency modulation.

```csharp
bool amplitudeModulationSupported = DeviceCapabilities.hasAmplitudeModulation;
bool frequencyModulationSupported = DeviceCapabilities.hasFrequencyModulation;
```

--------------------------------

### Load a scene additively with custom settings

Source: https://feel-docs.moremountains.com/mm-scene-loading.html

Configures additive loading behavior using the MMAdditiveSceneLoadingManagerSettings class.

```csharp
MMAdditiveSceneLoadingManagerSettings mySettings = new MMAdditiveSceneLoadingManagerSettings();
mySettings.LoadingSceneName = "MyAdditiveLoadingSceneName";
MMAdditiveSceneLoadingManager.LoadScene("TheNameOfMyDestinationScene", mySettings);
```

--------------------------------

### Initialization

Source: https://feel-docs.moremountains.com/mmf-player.html

Re-initializes the MMF_Player, ensuring runtime changes to feedback settings are applied.

```APIDOC
## Initialization

### Description
Re-initializes the MMF_Player. This is necessary if feedback settings were modified at runtime, as many feedbacks cache values during initialization.
```

--------------------------------

### Playing Haptic Presets

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Trigger predefined haptic patterns using the HapticPatterns class.

```csharp
HapticPatterns.PlayPreset(HapticPatterns.PresetType.Warning)
```

--------------------------------

### Playing Haptic Clips

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Play HD, device-agnostic haptic data by assigning a HapticClip to a script and using the HapticController.

```csharp
using UnityEngine;
using Lofelt.NiceVibrations;
public class PlayerCharacter : MonoBehaviour
{
   // Shows a GUI element in the inspector window to select a jump haptic
   public HapticClip jumpHaptic;
   public void Jump()
   {
      // Plays the jumpHaptic
      HapticController.Play(jumpHaptic);
   }
}
```

--------------------------------

### Implement UI Hover Effects with MMF_Player

Source: https://feel-docs.moremountains.com/recipes.html

Trigger feedback sequences on pointer enter and exit events by implementing IPointerEnterHandler and IPointerExitHandler.

```csharp
using MoreMountains.Feedbacks;
using UnityEngine;
using UnityEngine.EventSystems;

public class TestPointer : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
{
	public MMF_Player MyPlayer;

	public void OnPointerEnter(PointerEventData eventData)
	{
		MyPlayer.Direction = MMFeedbacks.Directions.TopToBottom;
		MyPlayer.PlayFeedbacks();
	}

	public void OnPointerExit(PointerEventData eventData)
	{
		MyPlayer.Direction = MMFeedbacks.Directions.BottomToTop;
		MyPlayer.PlayFeedbacks();
	}
}
```

--------------------------------

### Add and customize a feedback

Source: https://feel-docs.moremountains.com/mmf-player.html

Creates a new feedback instance, configures its properties, and adds it to the MMF Player.

```csharp
MMF_Scale scale = new MMF_Scale();
scale.Label = "MyCustomLabel";
scale.AnimateScaleDuration = 15f;
MyTargetMMFPlayer.AddFeedback(scale);
```

--------------------------------

### Update CustomInitialization signature

Source: https://feel-docs.moremountains.com/mmf-player.html

Change the CustomInitialization method signature to accept MMF_Player instead of GameObject.

```csharp
protected override void CustomInitialization(GameObject owner)

// would become :

protected override void CustomInitialization(MMF_Player owner)
```

--------------------------------

### Registering Unity Events via code

Source: https://feel-docs.moremountains.com/mmf-player.html

Use the OnComplete listener on the MMF_Player.Events object. Ensure the TriggerUnityEvents flag is enabled on the MMF Player.

```csharp
using MoreMountains.Feedbacks;
using MoreMountains.Tools;
using UnityEngine;

public class Test : MonoBehaviour
{
	public MMF_Player MyPlayer;

	void OnPlayerComplete()
	{
		MMDebug.DebugLogTime("The MMF_Player is done playing its feedbacks.");
	}

	/// Make sure you add and remove your listener (usually on enable / on disable like this)
	private void OnEnable() { MyPlayer.Events.OnComplete.AddListener(OnPlayerComplete); }
	private void OnDisable() { MyPlayer.Events.OnComplete.RemoveListener(OnPlayerComplete); }
}
```

--------------------------------

### HapticController Global Settings

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Methods to toggle global haptic state and adjust the master output level.

```APIDOC
## HapticController Global Controls

### Description
Manage global haptic settings including enabling/disabling haptics and setting the master output level.

### Properties
- **HapticController.hapticsEnabled** (bool) - Set to true to enable all haptics, false to disable.
- **HapticController.outputLevel** (float) - Adjusts the global vibration strength (e.g., 0.5).
```

--------------------------------

### Configure HapticSource Properties

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Adjusts playback behavior such as looping, amplitude, and priority for a specific HapticSource.

```csharp
// Set the playback of a haptic clip to loop
SpringHapticSource.loop = true;

// Sets the level of amplitude for a haptic clip, e.g. vibration "strength"
SpringHapticSource.level = 1.1;

// Sets the playback priority of the HapticSource;
// Highest priority corresponds to 0, the lowest to 255
SpringHapticSource.priority = 0;
```

--------------------------------

### Create a custom MMF_Feedback class

Source: https://feel-docs.moremountains.com/creating_mmfeedbacks.html

Use this template to define a new feedback type by inheriting from MMF_Feedback and implementing the required lifecycle overrides.

```csharp
using UnityEngine;
using MoreMountains.Tools;

namespace MoreMountains.Feedbacks
{
    [AddComponentMenu("")]
    [System.Serializable]
    [FeedbackHelp("You can add a description for your feedback here.")]
    [FeedbackPath("ChosenPath/MyFeedbackNameGoesHere")]
    public class MMF_MyFeedbackName : MMF_Feedback
    {
        /// a static bool used to disable all feedbacks of this type at once
        public static bool FeedbackTypeAuthorized = true;
        /// use this override to specify the duration of your feedback (don't hesitate to look at other feedbacks for reference)
        public override float FeedbackDuration { get { return 0f; } }
        /// pick a color here for your feedback's inspector
    		#if UNITY_EDITOR
    			public override Color FeedbackColor { get { return MMFeedbacksInspectorColors.DebugColor; } }
    		#endif

    		protected override void CustomInitialization(MMF_Player owner)
    		{
    			base.CustomInitialization(owner);
    			// your init code goes here
    		}

        protected override void CustomPlayFeedback(Vector3 position, float feedbacksIntensity = 1.0f)
        {
            if (!Active || !FeedbackTypeAuthorized)
            {
                return;
            }            
            // your play code goes here
        }

        protected override void CustomStopFeedback(Vector3 position, float feedbacksIntensity = 1)
        {
	        if (!FeedbackTypeAuthorized)
	        {
		        return;
	        }            
	        // your stop code goes here
        }
    }
}
```

--------------------------------

### Load a scene additively

Source: https://feel-docs.moremountains.com/mm-scene-loading.html

Loads a scene additively using the MMAdditiveSceneLoadingManager.

```csharp
MMAdditiveSceneLoadingManager.LoadScene("TheNameOfMyDestinationScene");
```

--------------------------------

### Manage settings via MMSoundManagerEvent

Source: https://feel-docs.moremountains.com/mmsoundmanager.html

Triggers persistence operations like saving or loading manager settings.

```csharp
/// will save settings.
MMSoundManagerEvent.Trigger(MMSoundManagerEventTypes.SaveSettings);
```

--------------------------------

### Handle Haptic Completion Callbacks

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Subscribe to the PlaybackStopped event to trigger logic when a haptic effect finishes.

```C#
protected void OnHapticsStopped()
{
// do something when haptics stop - usually because they have finished playing
}

protected virtual void OnEnable()
{
   HapticController.PlaybackStopped += OnHapticsStopped;
}

protected virtual void OnDisable()
{
   HapticController.PlaybackStopped -= OnHapticsStopped;
}
```

--------------------------------

### Create a custom Rigidbody2D Mass Spring

Source: https://feel-docs.moremountains.com/springs.html

Inherit from MMSpringFloatComponent to create a spring that controls a float value on a Rigidbody2D component.

```csharp
using MoreMountains.Feedbacks;
using UnityEngine;
public class Rigidbody2DMassSpring : MMSpringFloatComponent<Rigidbody2D>
{
	public override float TargetFloat
	{
		get => Target.mass;
		set => Target.mass = value;
	}
}
```

--------------------------------

### Implement ImpulseDisabler class

Source: https://feel-docs.moremountains.com/screen-shakes.html

A MonoBehaviour script that toggles the authorization status of MMF_CinemachineImpulse feedbacks.

```csharp
using MoreMountains.FeedbacksForThirdParty;
using UnityEngine;

public class ImpulseDisabler : MonoBehaviour
{
	public void DisableAllImpulses()
	{
		MMF_CinemachineImpulse.FeedbackTypeAuthorized = false;
	}

	public void EnableAllImpulses()
	{
		MMF_CinemachineImpulse.FeedbackTypeAuthorized = true;
	}
}
```

--------------------------------

### Triggering MMF_Player via code

Source: https://feel-docs.moremountains.com/mmf-player.html

Demonstrates how to reference and trigger an MMF_Player component within a custom MonoBehaviour class.

```csharp
using UnityEngine;
using MoreMountains.Feedbacks;

public class CharacterJump : MonoBehaviour
{
    // we declare a public MMF_Player reference, that we'll set from our CharacterJump inspector
    public MMF_Player JumpFeedback;

    public void Jump()
    {
      // here we'd put our Jump code
      JumpFeedback.PlayFeedbacks();
    }
}
```

--------------------------------

### Waiting for completion using Async Await

Source: https://feel-docs.moremountains.com/mmf-player.html

Use PlayFeedbacksTask to await the completion of a feedback sequence asynchronously.

```csharp
using System.Collections;
using System.Collections.Generic;
using MoreMountains.Feedbacks;
using MoreMountains.Tools;
using UnityEngine;

public class AwaitTest : MonoBehaviour
{
	public MMF_Player FirstPlayer;
	public MMF_Player SecondPlayer;

	[MMInspectorButton("Test")]
	public bool TestButton;

	public async void Test()
	{
		await FirstPlayer?.PlayFeedbacksTask(this.transform.position);
		SecondPlayer?.PlayFeedbacks();
	}
}
```

--------------------------------

### Load a scene with MMSceneLoadingManager

Source: https://feel-docs.moremountains.com/mm-scene-loading.html

Loads a scene using the MMSceneLoadingManager with a specified loading screen.

```csharp
MMSceneLoadingManager.LoadScene("TheNameOfMyDestinationScene", "LoadingScreen");
```

--------------------------------

### Invoke Spring Methods

Source: https://feel-docs.moremountains.com/springs.html

Call methods like MoveTo or Bump on the spring instance to trigger movement.

```csharp
MySpring.MoveTo(2f); // you could also call Bump, or MoveToAdditive, etc
```

--------------------------------

### Listen to MMFeedbacksEvents via code

Source: https://feel-docs.moremountains.com/mmf-player.html

Registers for feedback events on Enable and unregisters on Disable to handle specific event types like Complete.

```csharp
using UnityEngine;
using MoreMountains.Feedbacks;
using MoreMountains.Tools;

public class OnCompleteTest : MonoBehaviour
{
    public void OnMMFeedbacksEvent(MMFeedbacks source, MMFeedbacksEvent.EventTypes type)
    {
        switch (type)
        {
            case MMFeedbacksEvent.EventTypes.Complete:
                Debug.Log("The feedback "+source.name+" just completed.");
                break;
        }
    }

    private void OnEnable()
    {
        MMFeedbacksEvent.Register(OnMMFeedbacksEvent);  
    }
    private void OnDisable()
    {
        MMFeedbacksEvent.Unregister(OnMMFeedbacksEvent);  
    }
}
```

--------------------------------

### Migrate class inheritance

Source: https://feel-docs.moremountains.com/mmf-player.html

Update class declarations when converting legacy MMFeedback scripts to the new MMF_Feedback system.

```csharp
public class MMFeedbackTest : MMFeedback

// would become :

public class MMF_Test : MMF_Feedback
```

--------------------------------

### MMSoundManagerEvent

Source: https://feel-docs.moremountains.com/mmsoundmanager.html

Manages global settings for the MMSoundManager.

```APIDOC
## MMSoundManagerEvent

### Description
Triggers system-level actions such as saving, loading, or resetting settings.

### Usage
```csharp
MMSoundManagerEvent.Trigger(MMSoundManagerEventTypes.SaveSettings);
```
```

--------------------------------

### Create MMF Player and Feedbacks at Runtime

Source: https://feel-docs.moremountains.com/mmf-player.html

This component generates an MMF_Player, iterates through child transforms to add scale and pause feedbacks, and triggers the playback.

```csharp
using MoreMountains.Feedbacks;
using MoreMountains.Tools;
using UnityEngine;

/// <summary>
/// A test class that will automatically generate a MMF Player, containing as many scale feedbacks as this object has children.
/// To test it :
/// - create a new scene, and a new object in it. Add this component to it.
/// - create a bunch of cubes, position them where you want, then parent them to this object.
/// - press play in the editor, then press the "Create" button on this component's inspector
/// </summary>
public class DynamicPlayerCreator : MonoBehaviour
{
	// an inspector test button to trigger the Create method
	[MMInspectorButton("Create")] public bool CreateBtn;

	private void Create()
	{
		// we create a MMF Player
		MMF_Player newPlayer = this.gameObject.AddComponent<MMF_Player>();
		// we're going to play this MMF Player right after having created it, we'll initialize it manually.
		// we do this to avoid its Initialization method to run on its Start, which would be after we've played it
		newPlayer.InitializationMode = MMFeedbacks.InitializationModes.Script;

		if (transform.childCount == 0)
		{
			Debug.LogWarning("[DynamicCreation test class] to test this class, create a number of cubes, position them randomly, then parent them to this object.");
			return;
		}

		// for each child transform
		for (int i = 0; i < transform.childCount; i++)
		{
			Transform childTransform = transform.GetChild(i);

			// we create a new scale feedback, tweak its target, and add it to the player
			MMF_Scale newScaleFeedback = new MMF_Scale();
			newScaleFeedback.Label = "Scale child " + i;
			newScaleFeedback.AnimateScaleTarget = childTransform;
			newPlayer.AddFeedback(newScaleFeedback);

			// we create a pause feedback, define its pause duration, and add it to the player
			MMF_Pause newPauseFeedback = new MMF_Pause();
			newPauseFeedback.Label = "Pause " + i;
			newPauseFeedback.PauseDuration = 0.2f;
			newPlayer.AddFeedback(newPauseFeedback);
		}

		// we initialize and play our player
		newPlayer.Initialization();
		newPlayer.PlayFeedbacks();
	}
}
```

--------------------------------

### MMF_Player Methods

Source: https://feel-docs.moremountains.com/core-concepts.html

Methods available on the MMF_Player class to initialize, play, stop, and manage feedback sequences.

```APIDOC
## MMF_Player.Initialization()

### Description
Initializes the player and all its feedbacks, ensuring everything is correctly set up before playback. This is called automatically on Start by default, but should be called manually after any runtime changes.

## MMF_Player.PlayFeedbacks()

### Description
Triggers the player to execute its sequence of feedbacks.

## MMF_Player.PlayFeedbacks(Vector3 position, float intensity)

### Description
Triggers the player to execute its sequence of feedbacks, passing a specific position and intensity to feedbacks that support these parameters.

### Parameters
- **position** (Vector3) - Required - The world position for the feedback effect.
- **intensity** (float) - Required - The intensity multiplier for the feedback effect.

## MMF_Player.StopFeedbacks()

### Description
Stops the player, preventing any further feedbacks in the sequence from playing.

## MMF_Player.SkipToTheEnd()

### Description
Skips the sequence to its end, setting all feedback targets to their final state. Note: This requires the player to be currently playing and may take up to 3 frames to complete.

## MMF_Player.RestoreInitialValues()

### Description
Reverts all feedback targets to their initial values using a dedicated implementation per feedback.

## MMF_Player.ForceInitialValues()

### Description
Forces feedbacks that support it to reset to the start of their transitions. This is a legacy method that plays and instantly stops the feedbacks; RestoreInitialValues is recommended instead.
```

--------------------------------

### Triggering Emphasis and Constant Vibrations

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Use HapticPatterns to trigger short emphasis haptics or constant vibrations with specified amplitude and frequency.

```csharp
HapticPatterns.PlayEmphasis(1.0f, 0.0f);
```

```csharp
HapticPatterns.PlayConstant(1.0f, 0.0f, 1.0f);
```

--------------------------------

### Load a scene natively in Unity

Source: https://feel-docs.moremountains.com/mm-scene-loading.html

Uses the standard Unity SceneManager to load a scene by name.

```csharp
SceneManager.LoadScene("TheNameOfMyDestinationScene");
```

--------------------------------

### Checking Advanced Haptic Requirements

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Determine if the device meets the requirements for advanced haptic features like haptic clips.

```csharp
if (DeviceCapabilities.meetsAdvancedRequirements == true)
```

--------------------------------

### Update MMHealthBar via Script

Source: https://feel-docs.moremountains.com/mmtools.html

Demonstrates how to programmatically update an MMHealthBar component by passing current, minimum, and maximum health values.

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using MoreMountains.Tools;

/// <summary>
/// A simple class used to interact with a MMHealthBar component and test it
/// To use it, add it to an object with a MMHealthBar, and at runtime, move its CurrentHealth slider, and press the Test button to update the bar
/// </summary>
public class TestMMHealthBar : MonoBehaviour
{
    [Range(0f, 100f)]
    public float CurrentHealth = 50f;

    protected float _minimumHealth = 0f;
    protected float _maximumHealth = 100f;
    protected MMHealthBar _targetHealthBar;

    [MMInspectorButton("Test")] public bool TestButton;

    protected virtual void Awake()
    {
        _targetHealthBar = this.gameObject.GetComponent<MMHealthBar>();
    }

    public virtual void Test()
    {
        if (_targetHealthBar != null)
        {
            _targetHealthBar.UpdateBar(CurrentHealth, _minimumHealth, _maximumHealth, true);    
        }
    }
}
```

--------------------------------

### Controlling MMProgressBar values via script

Source: https://feel-docs.moremountains.com/mm-progress-bar.html

Use UpdateBar methods to trigger visual feedback effects, or SetBar methods to update the bar state instantly.

```csharp
// updates the bar to the specified value, between a min and a max that you specify, causing a bump 
TargetProgressBar.UpdateBar(Value, SomeMinValue, SomeMaxValue);
// so for example, this would put a bar at 50% : 
TargetProgressBar.UpdateBar(20f, 0f, 40f);
// updates the bar to the specified normalized value, a value between 0f and 1f, causing a bump
TargetProgressBar.UpdateBar01(NormalizedValue);
// so for example, this would put a bar at 50% : 
TargetProgressBar.UpdateBar01(0.5f);

// instantly sets the bar value to the specified value, without causing a bump
TargetProgressBar.SetBar(Value, SomeMinValue, SomeMaxValue);
// instantly sets the bar value to the specified normalized value, without causing a bump
TargetProgressBar.SetBar01(NormalizedValue);
```

--------------------------------

### Trigger Playlist Events

Source: https://feel-docs.moremountains.com/mmsoundmanager.html

Use the event system to control playlist managers across different channels without requiring direct references.

```csharp
MMPlaylistPlayNextEvent.Trigger(0);
```

```csharp
// plays the playlist on channel 2
MMPlaylistPlayEvent.Trigger(2);
// plays the next song
MMPlaylistPlayNextEvent.Trigger(0);
// plays the previous song
MMPlaylistPlayPreviousEvent.Trigger(0);
// stops the playlist
MMPlaylistStopEvent.Trigger(0);
// pauses the playlist (use a play event to resume)
MMPlaylistPauseEvent.Trigger(Channel);
// plays the song at index 3 on channel 0
MMPlaylistPlayIndexEvent.Trigger(0, 3);
// applies a volume multiplier of 0.5 on the playlist manager at channel 0, instantly
MMPlaylistVolumeMultiplierEvent.Trigger(0, 0.5f, true);
```

--------------------------------

### Modulate Haptics at Runtime

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Adjust amplitude and frequency envelopes dynamically using clipLevel and clipFrequencyShift.

```C#
// Multiplies all amplitude envelope breakpoints by 0.7
HapticController.clipLevel = 0.7;

// Shifts all the frequency envelope breakpoints by 0.2
HapticController.clipFrequencyShift = 0.2;
```

--------------------------------

### HapticSource Component API

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Methods and properties for controlling individual HapticSource components, including playback and modulation.

```APIDOC
## HapticSource Component

### Description
Controls individual haptic clips, allowing for playback, looping, priority management, and real-time modulation.

### Methods
- **Play()** - Triggers the playback of the assigned HapticClip.

### Properties
- **loop** (bool) - Set to true to loop the haptic clip.
- **level** (float) - Sets the amplitude/strength of the vibration.
- **priority** (int) - Sets playback priority (0 is highest, 255 is lowest).
- **frequencyShift** (float) - Modulates the frequency of the haptic effect.
```

--------------------------------

### Listen to State Changes

Source: https://feel-docs.moremountains.com/mmstatemachine.html

Implements MMEventListener to react to state changes triggered by an MMStateMachine.

```csharp
using MoreMountains.Tools;
using UnityEngine;

/// an example of a listening class that will act when the character changes state
public class MyListeningClass : MonoBehaviour, MMEventListener<MMStateChangeEvent<MyCharacter.MovementStates>>
{
    // on enable we start listening for event changes   
    private void OnEnable()
    {
        this.MMEventStartListening<MMStateChangeEvent<MyCharacter.MovementStates>>();
    }

    // on disable we stop listening for event changes
    private void OnDisable()
    {
        this.MMEventStopListening<MMStateChangeEvent<MyCharacter.MovementStates>>();
    }

    // when we catch a new state change event, we can then play any logic we want
    public void OnMMEvent(MMStateChangeEvent<MyCharacter.MovementStates> movementStateEvent)
    {
        // we can do stuff based on the new state our state machine is now in
        switch (movementStateEvent.NewState)
        {
            case MyCharacter.MovementStates.Jumping:
                Debug.Log("we're jumping now");
                break;
            case MyCharacter.MovementStates.Dashing:
                Debug.Log("we're dashing now");
                break;
        }

        // or based on the state it was in previously
        switch (movementStateEvent.PreviousState)
        {
            case MyCharacter.MovementStates.Running:
                // we can also always get a reference to the gameobject that triggered the event
                Debug.Log("object "+movementStateEvent.Target+" was running but we're not running anymore");
                break;
        }
    }
}
```

--------------------------------

### Reinitialize Haptics for AdMob on iOS

Source: https://feel-docs.moremountains.com/nice-vibrations.html

Release and reinitialize native haptic bindings around advertisement calls to prevent sound issues on iOS.

```csharp
// release haptic binding
LofeltHaptics.Release()

// wait until ad is closed
await ShowRewardedAd();

// initializing haptic binding
LofeltHaptics.Initialize();
```

--------------------------------

### Trigger Floating Text with Intensity

Source: https://feel-docs.moremountains.com/mm-floating-text.html

Demonstrates how to pass a dynamic intensity value to an MMF_Player feedback, which can be used to display damage values.

```csharp
using MoreMountains.Feedbacks;
using UnityEngine;

public class TestIntensityAsValue : MonoBehaviour
{
	[MMFInspectorButton("TriggerFeedback")]
	public bool TriggerFeedbackButton;
	private MMF_Player _myPlayer;

	private void Start()
	{
		// on start we grab our MMF Player component
		_myPlayer = this.gameObject.GetComponent<MMF_Player>();
	}

	private void TriggerFeedback()
	{
		float randomIntensity = Random.Range(0f, 100f);
		_myPlayer.PlayFeedbacks(this.transform.position, randomIntensity);
	}
}
```

--------------------------------

### Sequence audio events with MMSoundManager

Source: https://feel-docs.moremountains.com/mmsoundmanager.html

Uses a coroutine to play a sound, fade it out over a specified duration, and free the sound resource using a unique ID.

```csharp
using System.Collections;
using System.Collections.Generic;
using MoreMountains.Tools;
using UnityEngine;

public class Tester : MonoBehaviour
{

  public AudioClip MyClip;
  [MMInspectorButton("Test")]
  public bool TestBtn;

  private int _mySoundID = 50;
  private float _fadeDuration = 5f;

  public void Test()
  {
      StartCoroutine(SoundSequence());
  }

  private IEnumerator SoundSequence()
  {
      // plays the sound, notice we pass it a unique ID
      MMSoundManagerPlayOptions options;
      options = MMSoundManagerPlayOptions.Default;
      options.MmSoundManagerTrack = MMSoundManager.MMSoundManagerTracks.Music;
      options.ID = _mySoundID;
      MMSoundManagerSoundPlayEvent.Trigger(MyClip, options);

      // starts to fade it out (using the ID we passed earlier)
      yield return null;
      MMSoundManagerSoundFadeEvent.Trigger(MMSoundManagerSoundFadeEvent.Modes.StopFade, _mySoundID, _fadeDuration, 0f, new MMTweenType(MMTween.MMTweenCurve.EaseInCubic));

      // frees the sound at the end (still using that same ID)
      yield return MMCoroutine.WaitFor(_fadeDuration);
      MMSoundManagerSoundControlEvent.Trigger(MMSoundManagerSoundControlEventTypes.Free, _mySoundID);
  }

}
```

--------------------------------

### Triggering MMF_Player Feedbacks

Source: https://feel-docs.moremountains.com/getting-started.html

Use these methods to execute feedback sequences during specific game events.

```csharp
JumpFeedback?.PlayFeedbacks();
```

```csharp
LandingFeedback?.PlayFeedbacks();
```

--------------------------------

### Retrieve Feedback Components

Source: https://feel-docs.moremountains.com/mmf-player.html

Use GetFeedbackOfType or GetFeedbacksOfType to access specific feedback instances or lists of feedbacks from an MMF Player.

```csharp
// will return the first MMF_Scale found on that MMF_Player
MMF_Scale scaleFeedback = MyTargetMMFPlayer.GetFeedbackOfType<MMF_Scale>();

// will return a list of all MMF_Scale found on that MMF_Player
List<MMF_Scale> scaleFeedbacks = MyTargetMMFPlayer.GetFeedbacksOfType<MMF_Scale>();

// will return the first MMF_Scale found on that MMF_Player whose label matches "MyCustomLabel"
MMF_Scale scaleFeedback = MyTargetMMFPlayer.GetFeedbackOfType<MMF_Scale>("MyCustomLabel");

// will return a list of all the MMF_Scale found on that MMF_Player whose label matches "MyCustomLabel"
List<MMF_Scale> scaleFeedbacks = MyTargetMMFPlayer.GetFeedbacksOfType<MMF_Scale>("MyCustomLabel");
```

--------------------------------

### Spring Methods

Source: https://feel-docs.moremountains.com/springs.html

A collection of methods available to control the movement and state of a spring component.

```APIDOC
## MoveTo(newValue)

### Description
Moves the spring to the specified value, using its damping and frequency settings to handle value movement.

## MoveToAdditive(newValue)

### Description
Moves the spring to a value equal to its current value + the newValue passed in parameters.

## MoveToSubtractive(newValue)

### Description
Moves the spring to a value equal to its current value minus the newValue passed in parameters.

## MoveToRandom

### Description
Moves the spring to a new value picked between a min and a max.

## MoveToInstant(newValue)

### Description
Instantly moves the spring to the specified value.

## Bump(bumpAmount)

### Description
Bumps, or “pushes” the spring by the specified amount.

## BumpRandom

### Description
Bumps the spring with an amount picked between a min and a max.

## Stop

### Description
Stops the spring’s movement instantly.

## Finish

### Description
Moves the spring to its final destination position, instantly.

## RestoreInitialValue

### Description
Restores the spring’s target value to the one it had initially (either when the spring got enabled, or when ResetInitialValue() was last called).

## ResetInitialValue

### Description
Sets the spring’s target’s current value as its initial position, to be potentially restored later, via a call to RestoreInitialValue().
```

--------------------------------

### Wait for MMF Player in a Coroutine

Source: https://feel-docs.moremountains.com/recipes.html

Use PlayFeedbacksCoroutine to yield execution until a feedback sequence completes. Requires the MMF_Player component to be assigned.

```csharp
using System.Collections;
using MoreMountains.Feedbacks;
using MoreMountains.Tools;
using UnityEngine;

public class TestCoroutine : MonoBehaviour
{
	public MMF_Player MyPlayer;

	[MMFInspectorButton("TestCoPlay")]
	public bool TestCoPlayBtn;

	private void TestCoPlay()
	{
		StartCoroutine(TestCoPlayCo());
	}

	private IEnumerator TestCoPlayCo()
	{
		MMDebug.DebugLogTime("start");
		yield return MyPlayer.PlayFeedbacksCoroutine(this.transform.position);
		MMDebug.DebugLogTime("end");
	}
}
```

--------------------------------

### Play a sound via MMSoundManagerSoundPlayEvent

Source: https://feel-docs.moremountains.com/mmsoundmanager.html

Triggers a sound playback on a specific track at a given position.

```csharp
/// will play a clip (here ours is called ExplosionSfx) on the SFX track, at the position of the object calling it
MMSoundManagerSoundPlayEvent.Trigger(ExplosionSfx, MMSoundManager.MMSoundManagerTracks.Sfx, this.transform.position);
```

--------------------------------

### Add a feedback by type

Source: https://feel-docs.moremountains.com/mmf-player.html

Adds a new feedback to the MMF Player by specifying its type.

```csharp
MyTargetMMFPlayer.AddFeedback(typeof(MMF_Scale));
```
Tokens:
Raw