➕Integration

In this section we will learn how to integrate the system.

Scriptable Animation System offers a streamlined integration process. Let's start with the custom controller integartion. We will use the FPSController script from the demo project as an example.

Initialization

First, you need to add references to the framework core components:

private FPSAnimator _fpsAnimator; // Central management component.
private UserInputController _userInput; // Dynamic input system.
private FPSCameraController _fpsCamera; // Camera system.
private IPlayablesController _playablesController; // Dynamic animation system.
private RecoilAnimation _recoilAnimation; // Recoil effect component.

Then, make sure to initialize all the components:

_fpsAnimator = GetComponent<FPSAnimator>();
_userInput = GetComponent<UserInputController>();
_fpsCamera = GetComponentInChildren<FPSCameraController>();
_playablesController = GetComponent<IPlayablesController>();
_recoilAnimation = GetComponent<RecoilAnimation>();

Weapon change

When switching weapons, we need to link a new Animator Profile:

private void EquipWeapon()
{     
    ...
    
    // Where gun is your active weapon/item.
    _fpsAnimator.LinkAnimatorProfile(gun.gameObject);     
    _animator.CrossFade("CurveEquip", 0.15f);
}

Additionally we play an Equip animation, which is optional and depends on your project implementation specifically. A similar logic is applied to the UnEquip method.

Aiming

private void ToggleAiming()
{
    if (_aimState != FPSAimState.Aiming)
    {
        _aimState = FPSAimState.Aiming;
        _userInput.SetValue(FPSANames.IsAiming, true);
        _fpsCamera.UpdateTargetFOV(60f);
    }
    else
    {
        DisableAim();
        _fpsCamera.UpdateTargetFOV(90f);
    }

    _recoilAnimation.isAiming = IsAiming();
}

Additionally, we access the FPSCameraController, and adjust the target FOV. We also adjust the recoilAnimation aiming status, which is important as it will adjust the animation accordingly.

Playing animations

To play an animation, you need to call the:

// Where yourAnimation is an Animation Asset.
_playablesController.PlayAnimation(yourAnimation, 0f);

You can also specify the start time of the animation as a second parameter, which might be useful for mechanics like staged reloads.

Recoil

The recoil is implemented via Recoil Animation component and Camera Shakes. First we need to initialize the Recoil Animation component when a gun is equipped:

_recoilAnimation.Init(gun.recoilData, gun.fireRate, gun.isAuto ? FireMode.Auto : FireMode.Semi);

You only need to add the Recoil Data to your custom weapon class. The Recoil Data is a Scriptable Object, that contains the information about the procedural recoil animation.

Next, we need to apply the recoil effect in runtime:

// Called every shot.
private void Fire()
{
    // Make sure to add an FPSCameraShake public field to your weapon class.
    _fpsCamera.PlayCameraShake(GetGun().cameraShake);
    if (_recoilAnimation != null) _recoilAnimation.Play();
}

// Called when firing key is released.
private void StopFiring()
{
    if (_recoilAnimation != null) _recoilAnimation.Stop();
}

Making adjustments

Sometimes it is necessary to adjust our system's behavior in runtime, depending on gameplay situations.

In the Scriptable Animation System it is implemented primarily via the Input System:

private void OnSprintStarted()
{
    _userInput.SetValue(FPSANames.StabilizationWeight, 0f);
    _userInput.SetValue(FPSANames.PlayablesWeight, 0f);
}

private void OnSprintEnded()
{
    _userInput.SetValue(FPSANames.StabilizationWeight, 1f);
    _userInput.SetValue(FPSANames.PlayablesWeight, 1f);
}

In the example above, we toggle the Playables systems and stabilization based on the sprinting status. You can adjust custom properties in a similar way, depending on the requirements of your project.