โž•Integration

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

FPS Animation Framework offers a streamlined integration process. Let's start with the custom controller integration. 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>();
_fpsAnimator.Initialize();
_userInput = GetComponent<UserInputController>();
_fpsCamera = GetComponentInChildren<FPSCameraController>();
_playablesController = GetComponent<IPlayablesController>();
_recoilAnimation = GetComponent<RecoilAnimation>();

Note: make sure to initialize the FPS Animator component!

Updating Input

When updating user input, we typically need to refresh aiming and movement inputs:

private void UpdateInput()
{
    ...
    _userInput.SetValue(FPSANames.MouseDeltaInput, new Vector4(deltaMouseX, deltaMouseY));
    _userInput.SetValue(FPSANames.MouseInput, new Vector4(mouseX, mouseY));
    _userInput.SetValute(FPSANames.MoveInput, new Vector4(moveX, moveY));
    ...
}

Weapon change

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

private void EquipWeapon()
{     
    ...
    _fpsAnimator.LinkAnimatorProfile(gun.gameObject);     
    ...
}

Aiming

private void OnAimPressed()
{
    _userInput.SetValue(FPSANames.IsAiming, true);
    _recoilAnimation.isAiming = true;
    _fpsCamera.UpdateTargetFOV(aimFov);
{

private void OnAimReleased()
{
    _userInput.SetValue(FPSANames.IsAiming, false);
    _recoilAnimation.isAiming = false;
    _fpsCamera.UpdateTargetFOV(defaultFov);
}

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 from code, 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 FPS Animation Framework 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.


At this point, the integration is complete. In the next section, we will learn more about dynamic animations.

Last updated