//CameraSystemCharacter.h
public:
DECLARE_EVENT_TwoParams(ACameraSystemCharacter, FOnTagContainerChanged, const FGameplayTag& /*ChangedTag*/, bool /*bExist*/);
FOnTagContainerChanged OnTagContainerChanged;
void AddTag(const FGameplayTag& Tag);
void RemoveTag(const FGameplayTag& Tag);
FGameplayTagContainer GetGameplayTags() const;
protected:
TMap<FGameplayTag, int32> TagMap;

//CameraSystemCharacter.срр
void ACameraSystemCharacter::AddTag(const FGameplayTag& Tag)
{
   auto& val = ++TagMap.FindOrAdd(Tag);
   OnTagContainerChanged.Broadcast(Tag, val > 0);
}
void ACameraSystemCharacter::RemoveTag(const FGameplayTag& Tag)
{
   auto& val = --TagMap.FindOrAdd(Tag);
   OnTagContainerChanged.Broadcast(Tag, val > 0);
}
FGameplayTagContainer ACameraSystemCharacter::GetGameplayTags() const
{
   FGameplayTagContainer tags;
  Algo::ForEach(TagMap, [&](const auto& it) { if (it.Value > 0) tags.AddTag(it.Key); });
  return tags;
}

//CameraModeComponent.h
UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class CAMERASYSTEMHABR_API UCameraModeComponent : public UActorComponent
{
  GENERATED_BODY()
};

//CameraMode.h
UCLASS(Abstract, Blueprintable, editinlinenew)
class UCameraMode: public UDataAsset
{
  ...
};

//CameraMode.h
USTRUCT(BlueprintType)
struct FCameraModeData
{
  GENERATED_BODY()
public:
bool CanActivateMode(const FGameplayTagContainer& TagsToCheck) const
{
  return ModeActivationConditions.IsEmpty() || ModeActivationConditions.Matches(TagsToCheck);
}
UCameraMode* GetCameraMode() const
{
  return CameraMode;
}
protected:
  UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Instanced)
  UCameraMode* CameraMode;
  UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
  FGameplayTagQuery ModeActivationConditions;
};

//CameraModeComponent.h
UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
class CAMERASYSTEMHABR_API UCameraModeComponent : public UActorComponent
{
  GENERATED_BODY()
   ...
protected:
virtual void BeginPlay() override();
void OnAbilityTagChanged(const FGameplayTag& Tag, bool TagExists);
protected:
UPROPERTY(EditDefaultsOnly)
TArray<FCameraModeData> CameraModes;
UPROPERTY()
UCameraMode* CurrentCameraMode;
TWeakObjectPtr<ACameraSystemCharacter> Character;
  ...
};

//CameraModeComponent.cpp
void UCameraModeComponent::BeginPlay()
{
  Super::BeginPlay();
  Character = CastChecked<ACameraSystemCharacter>(GetOwner());
  if (Character->IsLocallyControlled())
  {
    Character->OnTagContainerChanged.AddUObject(this, &UCameraModeComponent::OnAbilityTagChanged));
  }
}

//CameraModeComponent.cpp
void UCameraModeComponent::OnAbilityTagChanged(const FGameplayTag& Tag, bool TagExists)
{
  SetCameraMode(DetermineCameraMode(Character->GetGameplayTags()));
}
UCameraMode* UCameraModeComponent::DetermineCameraMode(const FGameplayTagContainer& Tags) const
{
  if (auto foundMode = Algo::FindByPredicate(CameraModes, [&](const auto modeData) {return modeData.CanActivateMode(Tags);}))
{
  return foundMode->GetCameraMode();
}
  return nullptr;
}
void UCameraModeComponent::SetCameraMode(UCameraMode* NewMode)
{
  CurrentCameraMode = NewMode;
}

//CameraSystemCharacter.h
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
void EnableSprint();
void DisableSprint();

//CameraSystemCharacter.cpp
void ACameraSystemCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
{
  PlayerInputComponent->BindAction("Sprint", IE_Pressed, this, &ACameraSystemCharacter::EnableSprint);
  PlayerInputComponent->BindAction("Sprint", IE_Released, this, &ACameraSystemCharacter::DisableSprint);
}
void ACameraSystemCharacter::EnableSprint()
{ AddTag(FGameplayTag::RequestGameplayTag(TEXT("CharacterState.Sprint")));
}
void ACameraSystemCharacter::DisableSprint()
{
RemoveTag(FGameplayTag::RequestGameplayTag(TEXT("CharacterState.Sprint")));
}

//CameraMode.h
UCLASS(Abstract, Blueprintable, editinlinenew)
class UCameraMode : public UDataAsset
{
  GENERATED_BODY()
public:
//Cкорость интерполяции для текущего мода
UPROPERTY(EditDefaultsOnly, meta = (ClampMin = 0.f, UIMin = 0.f))
float InterpolationSpeed = 5.f;
//Продолжительность смены скорости интерполяции при переходе из одного мода в другой, требуется, чтобы достичь максимальной плавности при переходе между модами.
UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, meta = (ClampMin = 0.f, UIMin = 0.f))
float InterpolationLerpDuration = 0.5f;
//Длина SprintArm в камера моде
UPROPERTY(EditDefaultsOnly, meta = (ClampMin = 0.f, UIMin = 0.f))
float ArmLength = 250.f;
//Значение FOV для камеры
UPROPERTY(EditDefaultsOnly, meta = (ClampMin = 0.f, UIMin = 0.f))
float Fov= 60.f;
//оффсет камеры относительно SprigArm
UPROPERTY(EditDefaultsOnly)
FVector CameraOffset = FVector::ZeroVector;
//Параметр, который будет включать вращение персонажа по направлению контроллера, например, для режима прицеливания
UPROPERTY(EditDefaultsOnly)
bool bUseControllerDesiredRotation = false;
};

//CameraModeComponent.h
protected:
virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
virtual void BeginPlay() override;
void SetCameraMode(UCameraMode* NewMode);
float GetInterpSpeed() const;
void UpdateCameraMode (float DeltaTime);
void UpdateSpringArmLength(float DeltaTime);
void UpdateCameraLocation(float DeltaTime);
void UpdateFOV(float DeltaTime);
//Мировое время, во время смены одного камера мода на другой, потребуется, чтобы реализовать плавный переход скорости интерполяции между модами
float TimeSecondsAfterSetNewMode = 0.f;
//Скорость интерполяции с прошлого мода, требуется, чтобы плавно перейти в новую скорость интерполяции
float PreviousInterpSpeed = 0.f;
//Камера менеджер, пригодится в  дальнейшем для смены значений FOV
TWeakObjectPtr<APlayerCameraManager> PlayerCameraManager;

//CameraModeComponent.cpp
void UCameraModeComponent::SetCameraMode(UCameraMode* NewMode)
{
  if (CurrentCameraMode != NewMode)
  {
    PreviousInterpSpeed = CurrentCameraMode == nullptr ? NewMode->InterpolationSpeed : CurrentCameraMode->InterpolationSpeed;
    CurrentCameraMode = NewMode;
    Character->GetCharacterMovement()->bUseControllerDesiredRotation = CurrentCameraMode->bUseControllerDesiredRotation;
    Character->GetCharacterMovement()->bOrientRotationToMovement = !CurrentCameraMode->bUseControllerDesiredRotation;
    TimeSecondsAfterSetNewMode  = GetWorld()->GetTimeSeconds();
  }
}
void UCameraModeComponent::BeginPlay()
{
  ...
  PlayerCameraManager = CastChecked<APlayerController> (Character->GetController())->PlayerCameraManager;
  ...
}
float UCameraModeComponent::GetInterpSpeed() const
{
  auto timeAfterModeWasChanged = GetWorld()->GetTimeSeconds() - TimeSecondsAfterSetNewMode;
  auto lerpDuration = CurrentCameraMode->InterpolationLerpDuration;
  auto lerpAlpha = FMath::IsNearlyZero(lerpDuration) ? 1.f : FMath::Min(1.f, timeAfterModeWasChanged / lerpDuration);
  return FMath::Lerp(PreviousInterpSpeed, CurrentCameraMode->InterpolationSpeed, lerpAlpha);
}
void UCameraModeComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
  Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
  UpdateCameraMode(DeltaTime);
}
void UCameraModeComponent::UpdateCameraMode(float DeltaTime)
{
if (CurrentCameraMode != nullptr)
  {
    UpdateSpringArmLength(DeltaTime);
    UpdateSpringArmPivotLocation(DeltaTime);
    UpdateCameraLocation(DeltaTime);
  }
}
//Интерполяция параметра TargetArmLength
void UCameraModeComponent::UpdateSpringArmLength(float DeltaTime)
{
  const auto currentLength = Character->GetCameraBoom()->TargetArmLength;
  const auto targetLength = CurrentCameraMode->ArmLength;
  const auto newArmLength = FMath::FInterpTo(currentLength, targetLength, DeltaTime, GetInterpSpeed());
  Character->GetCameraBoom()->TargetArmLength = newArmLength;
}
void UCameraModeComponent::UpdateCameraLocation(float DeltaTime)
{
  const auto currentLocation = Character->GetCameraBoom()->SocketOffset;
  const auto targetLocation = CurrentCameraMode->CameraOffset;
  FVector newLocation = FMath::VInterpTo(currentLocation, targetLocation, DeltaTime, GetInterpSpeed());
  Character->GetCameraBoom()->SocketOffset = newLocation;
}
//Смена значений FOV
void UCameraModeComponent::UpdateFOV(float DeltaTime)
{
  const auto currentFov = PlayerCameraManager->GetFOVAngle();
  const auto targetFov = CurrentCameraMode->Fov;
  auto newFov = FMath::FInterpTo(currentFov, targetFov, DeltaTime, GetInterpSpeed());
  PlayerCameraManager->SetFOV(newFov);
}