Minigame

.gitattributes

@@ -1,4 +0,0 @@
-ReleaseBuilds/** filter=lfs diff=lfs merge=lfs -text
-Images/** filter=lfs diff=lfs merge=lfs -text
-Fonts/** filter=lfs diff=lfs merge=lfs -text
-Audio/** filter=lfs diff=lfs merge=lfs -text

Audio/.gitattributes

@@ -0,0 +1 @@
+./** filter=lfs diff=lfs merge=lfs -text

Fonts/.gitattributes

@@ -0,0 +1 @@
+./** filter=lfs diff=lfs merge=lfs -text

Images/.gitattributes

@@ -0,0 +1 @@
+./** filter=lfs diff=lfs merge=lfs -text

ReleaseBuilds/.gitattributes

@@ -0,0 +1 @@
+./** filter=lfs diff=lfs merge=lfs -text

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CameraModeBase.cpp

@@ -10,8 +10,8 @@
 #include "InputMappingContext.h"
 #include "Kismet/GameplayStatics.h"
 
-#include "CustomGameInstanceBase.h"
 #include "CustomGameUserSettings.h"
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 
 ACameraModeBase::ACameraModeBase()
@@ -25,30 +25,12 @@ void ACameraModeBase::BeginPlay()
 
     auto world = GetWorld();
 
-    //GetMovementComponent()->speed
-    //    GetCharacterMovement()->MaxWalkSpeed = moveSpeed;
-
     auto gameSettings = UCustomGameUserSettings::GetCustomGameUserSettings();
 
     if(auto camera = FindComponentByClass<UCameraComponent>())
     {
         camera->PostProcessSettings.MotionBlurAmount = gameSettings->bUseMotionBlur ? 1.0f : 0.0f;
     }
-
-    if(auto PC = Cast<APlayerController>(GetController()))
-    {
-        if(auto inputSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PC->GetLocalPlayer()))
-        {
-            if(auto GI = Cast<UCustomGameInstanceBase>(GetWorld()->GetGameInstance()))
-            {
-                inputSubsystem->ClearAllMappings();
-                for(auto& inputContext : GI->inputContexts)
-                {
-                    inputSubsystem->AddMappingContext(inputContext.LoadSynchronous(), 0);
-                }
-            }
-        }
-    }
 }
 
 void ACameraModeBase::Tick(float DeltaTime)

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CommonFunctions.cpp

@@ -7,7 +7,7 @@
 #include "Kismet/GameplayStatics.h"
 #include "UObject/Object.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomGameInstance.h"
 #include "Levels/LevelBase.h"
 #include "PlayerBase.h"
 
@@ -86,7 +86,7 @@ void UCommonFunctions::EnterSlowMotion(float duration)
 
     SlowMotion::targetDilation = SlowMotion::slowDilation;
 
-    auto GI = UCustomGameInstanceBase::GetGameInstance();
+    auto GI = UCustomGameInstance::GetGameInstance();
     if(!GI)
         return;
 
@@ -101,7 +101,7 @@ void UCommonFunctions::ExitSlowMotion(float duration)
 
     SlowMotion::targetDilation = SlowMotion::normalDilation;
 
-    auto GI = UCustomGameInstanceBase::GetGameInstance();
+    auto GI = UCustomGameInstance::GetGameInstance();
     if(!GI)
         return;
 
@@ -116,7 +116,7 @@ FWorldDilationChangedDelegate& UCommonFunctions::GetWorldDilationChangedDelegate
 
 void UCommonFunctions::SlowMotionTick()
 {
-    const UWorld* world = UCustomGameInstanceBase::GetGameInstance()->GetWorld();
+    const UWorld* world = UCustomGameInstance::GetGameInstance()->GetWorld();
     const float currentDilation = UGameplayStatics::GetGlobalTimeDilation(world);
     float newDilation = FMath::FInterpTo(currentDilation, SlowMotion::targetDilation, 1, SlowMotion::interpolationSpeed);
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomGameInstance.cpp

@@ -0,0 +1,74 @@
+// Oleg Petruny proprietary.
+
+#include "CustomGameInstance.h"
+
+#include "Kismet/GameplayStatics.h"
+#include "Kismet/KismetSystemLibrary.h"
+
+#include "CommonFunctions.h"
+#include "ContentLoader.h"
+#include "Levels/LevelBase.h"
+#include "PlayerBase.h"
+#include "SaveData.h"
+
+UCustomGameInstance* UCustomGameInstance::instance = nullptr;
+
+void UCustomGameInstance::Init()
+{
+    UGameInstance::Init();
+
+    instance = this;
+    contentLoader = NewObject<UContentLoader>(this);
+    saveData = Cast<USaveData>(UGameplayStatics::CreateSaveGameObject(USaveData::StaticClass()));
+}
+
+UCustomGameInstance* UCustomGameInstance::GetGameInstance()
+{
+    return instance;
+}
+
+UContentLoader* UCustomGameInstance::GetContentLoader()
+{
+    if(auto GI = GetGameInstance())
+        return GI->contentLoader;
+
+    return nullptr;
+}
+
+void UCustomGameInstance::SaveGame(FName checkpointName)
+{
+    auto levelScript = UCommonFunctions::GetCurrentLevelScript(this);
+    if(!levelScript)
+        return;
+
+    auto player = UCommonFunctions::GetPlayer(this);
+    if(!player)
+        return;
+    saveData->level = GetWorld()->GetFName();
+    saveData->state = levelScript->GetState();
+    saveData->checkpoint = checkpointName;
+    if(player->leftPocketItem)
+        saveData->playerLeftPocketItem = player->leftPocketItem->GetFName();
+    else
+        saveData->playerLeftPocketItem = FName(TEXT(""));
+    if(player->rightPocketItem)
+        saveData->playerRightPocketItem = player->rightPocketItem->GetFName();
+    else
+        saveData->playerRightPocketItem = FName(TEXT(""));
+
+    UGameplayStatics::SaveGameToSlot(saveData, TEXT("Save"), 0);
+}
+
+void UCustomGameInstance::LoadGame()
+{
+    saveData = Cast<USaveData>(UGameplayStatics::LoadGameFromSlot(TEXT("Save"), 0));
+    if(!saveData)
+        return;
+
+    UGameplayStatics::OpenLevel(this, saveData->level);
+}
+
+void UCustomGameInstance::ExitGame()
+{
+    UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, true);
+}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomGameInstance.h

@@ -4,29 +4,29 @@
 
 #include "Engine/GameInstance.h"
 
-#include "CustomGameInstanceBase.generated.h"
+#include "CustomGameInstance.generated.h"
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FLevelBeginnedDelegate, FName, levelName);
 
+/**
+ * Expands basic UE game instance.
+ * Manages saves, handles content loader and can shutdown the game.
+ */
 UCLASS()
-class UCustomGameInstanceBase : public UGameInstance
+class UCustomGameInstance : public UGameInstance
 {
     GENERATED_BODY()
 
 public:
+    /** Instantiates content loader, dummy save data and applies settings */
     virtual void Init() override;
 
     UFUNCTION(BlueprintPure)
-    static UCustomGameInstanceBase* GetGameInstance();
+    static UCustomGameInstance* GetGameInstance();
 
     UFUNCTION(BlueprintPure)
     static class UContentLoader* GetContentLoader();
 
-    UFUNCTION(BlueprintCallable, Category = Settings)
-    void ApplyMouseSettings();
-
-    void AppendInteractableModificatorClass(TSubclassOf<class UInteractableModificator> modificator);
-
     UFUNCTION(BlueprintCallable, Category = Save)
     void SaveGame(FName checkpointName);
     UFUNCTION(BlueprintCallable, Category = Save)
@@ -34,17 +34,11 @@ public:
     UFUNCTION(BlueprintCallable)
     void ExitGame();
 
-    static UCustomGameInstanceBase* instance;
+    static UCustomGameInstance* instance;
 
+    /** Public delegate called by ALevelBase instance on instantiation */
     FLevelBeginnedDelegate OnLevelBeginned;
 
-    UPROPERTY(EditDefaultsOnly)
-    TSet<TSubclassOf<class UInteractableActivator>> interactionsActivators;
-    TSet<TSubclassOf<class UInteractableModificator>> interactionsModificators;
-
-    UPROPERTY(EditDefaultsOnly)
-    TSet<TSoftObjectPtr<class UInputMappingContext>> inputContexts;
-
     UPROPERTY(VisibleAnywhere)
     class USaveData* saveData = nullptr;
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomGameInstanceBase.cpp

@@ -1,149 +0,0 @@
-// Oleg Petruny proprietary.
-
-
-#include "CustomGameInstanceBase.h"
-
-#include "EnhancedInputLibrary.h"
-#include "EnhancedInputSubsystems.h"
-#include "InputMappingContext.h"
-#include "Kismet/GameplayStatics.h"
-#include "Kismet/KismetSystemLibrary.h"
-
-#include "CommonFunctions.h"
-#include "ContentLoader.h"
-#include "CustomGameUserSettings.h"
-#include "Interactable/Activators/InCameraInteractableActivator.h"
-#include "Interactable/Activators/RaycastInteractableActivator.h"
-#include "Interactable/Modificators/ActivateInteractableModificator.h"
-#include "Interactable/Modificators/SawInteractableModificator.h"
-#include "Levels/LevelBase.h"
-#include "PlayerBase.h"
-#include "SaveData.h"
-
-UCustomGameInstanceBase* UCustomGameInstanceBase::instance = nullptr;
-
-void UCustomGameInstanceBase::Init()
-{
-    UGameInstance::Init();
-
-    instance = this;
-
-    contentLoader = NewObject<UContentLoader>(this);
-
-    interactionsActivators.Add(URaycastInteractableActivator::StaticClass());
-    interactionsActivators.Add(UInCameraInteractableActivator::StaticClass());
-
-    for(auto& modificator : interactionsModificators)
-    {
-        if(modificator.GetDefaultObject()->GetMappingContext())
-        {
-            inputContexts.Add(modificator.GetDefaultObject()->GetMappingContext());
-        }
-    }
-
-    ApplyMouseSettings();
-
-    saveData = Cast<USaveData>(UGameplayStatics::CreateSaveGameObject(USaveData::StaticClass()));
-}
-
-UCustomGameInstanceBase* UCustomGameInstanceBase::GetGameInstance()
-{
-    return instance;
-}
-
-UContentLoader* UCustomGameInstanceBase::GetContentLoader()
-{
-    if(auto GI = GetGameInstance())
-        return GI->contentLoader;
-
-    return nullptr;
-}
-
-void UCustomGameInstanceBase::ApplyMouseSettings()
-{
-    if(auto gameSettings = UCustomGameUserSettings::GetCustomGameUserSettings())
-    {
-        for(auto& context : inputContexts)
-        {
-            if(!context.LoadSynchronous())
-                continue;
-
-            for(auto& mapping : context.LoadSynchronous()->GetMappings())
-            {
-                if(mapping.Key == EKeys::Mouse2D)
-                {
-                    for(auto& modifier : mapping.Modifiers)
-                    {
-                        if(auto negate_modifier = Cast<UInputModifierNegate>(modifier))
-                        {
-                            negate_modifier->bY = !gameSettings->bMouseInverted;
-                        }
-                        if(auto scalar_modifier = Cast<UInputModifierScalar>(modifier))
-                        {
-                            scalar_modifier->Scalar = FVector{ gameSettings->GetMouseSensetivity() * 0.5 };
-                        }
-                    }
-                }
-            }
-            UEnhancedInputLibrary::RequestRebuildControlMappingsUsingContext(context.LoadSynchronous());
-        }
-    }
-}
-
-void UCustomGameInstanceBase::AppendInteractableModificatorClass(TSubclassOf<class UInteractableModificator> modificator)
-{
-    bool alreadyPresent = false;
-    interactionsModificators.Add(modificator, &alreadyPresent);
-    if(!alreadyPresent)
-    {
-        if(auto IC = modificator.GetDefaultObject()->GetMappingContext())
-        {
-            inputContexts.Add(IC);
-            if(auto PC = UGameplayStatics::GetPlayerController(GetWorld(), 0))
-            {
-                if(auto inputSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PC->GetLocalPlayer()))
-                {
-                    inputSubsystem->AddMappingContext(IC, 0);
-                }
-            }
-        }
-    }
-}
-
-void UCustomGameInstanceBase::SaveGame(FName checkpointName)
-{
-    auto levelScript = UCommonFunctions::GetCurrentLevelScript(this);
-    if(!levelScript)
-        return;
-
-    auto player = UCommonFunctions::GetPlayer(this);
-    if(!player)
-        return;
-    saveData->level = GetWorld()->GetFName();
-    saveData->state = levelScript->GetState();
-    saveData->checkpoint = checkpointName;
-    if(player->leftPocketItem)
-        saveData->playerLeftPocketItem = player->leftPocketItem->GetFName();
-    else
-        saveData->playerLeftPocketItem = FName(TEXT(""));
-    if(player->rightPocketItem)
-        saveData->playerRightPocketItem = player->rightPocketItem->GetFName();
-    else
-        saveData->playerRightPocketItem = FName(TEXT(""));
-
-    UGameplayStatics::SaveGameToSlot(saveData, TEXT("Save"), 0);
-}
-
-void UCustomGameInstanceBase::LoadGame()
-{
-    saveData = Cast<USaveData>(UGameplayStatics::LoadGameFromSlot(TEXT("Save"), 0));
-    if(!saveData)
-        return;
-
-    UGameplayStatics::OpenLevel(this, saveData->level);
-}
-
-void UCustomGameInstanceBase::ExitGame()
-{
-    UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, true);
-}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomPlayerController.cpp

@@ -0,0 +1,92 @@
+// Oleg Petruny proprietary.
+
+#include "CustomPlayerController.h"
+
+#include "EnhancedInputComponent.h"
+#include "EnhancedInputLibrary.h"
+#include "EnhancedInputSubsystems.h"
+#include "InputMappingContext.h"
+
+#include "CustomGameUserSettings.h"
+
+ACustomPlayerController* ACustomPlayerController::instance = nullptr;
+UEnhancedInputLocalPlayerSubsystem* ACustomPlayerController::subsystem = nullptr;
+UEnhancedInputComponent* ACustomPlayerController::input = nullptr;
+TSet<TSoftObjectPtr<UInputMappingContext>> ACustomPlayerController::contexts = {};
+
+void ACustomPlayerController::AppendInputContext(TSoftObjectPtr<class UInputMappingContext> context)
+{
+    if(!context.IsValid())
+        return;
+
+    ApplyMouseSettings(context);
+    contexts.Add(context);
+    if(subsystem)
+        subsystem->AddMappingContext(context.LoadSynchronous(), 0);
+}
+
+void ACustomPlayerController::BeginPlay()
+{
+    Super::BeginPlay();
+
+    instance = this;
+
+    subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(GetLocalPlayer());
+    if(subsystem)
+    {
+        subsystem->ClearAllMappings();
+        for(auto& inputContext : contexts)
+            subsystem->AddMappingContext(inputContext.LoadSynchronous(), 0);
+    }
+
+    input = Cast<UEnhancedInputComponent>(InputComponent);
+    if(input)
+    {
+        ((UInputComponent*)input)->BindAction(TEXT("AnyKey"), IE_Pressed, this, &ACustomPlayerController::OnAnyKeyPressed);
+        ((UInputComponent*)input)->BindAction(TEXT("AnyKey"), IE_Released, this, &ACustomPlayerController::OnAnyKeyReleased);
+    }
+}
+
+void ACustomPlayerController::ApplyMouseSettings(TSoftObjectPtr<class UInputMappingContext>& context)
+{
+    auto gameSettings = UCustomGameUserSettings::GetCustomGameUserSettings();
+    if(!gameSettings)
+        return;
+
+    if(!context.LoadSynchronous())
+        return;
+
+    for(auto& mapping : context.LoadSynchronous()->GetMappings())
+    {
+        if(mapping.Key != EKeys::Mouse2D)
+            continue;
+
+        for(auto& modifier : mapping.Modifiers)
+        {
+            if(gameSettings->bMouseInverted)
+            {
+                if(auto negate_modifier = Cast<UInputModifierNegate>(modifier))
+                {
+                    negate_modifier->bY = !negate_modifier->bY;
+                    continue;
+                }
+            }
+            if(auto scalar_modifier = Cast<UInputModifierScalar>(modifier))
+                scalar_modifier->Scalar = FVector{ gameSettings->GetMouseSensetivity() * 0.5 };
+        }
+    }
+
+    UEnhancedInputLibrary::RequestRebuildControlMappingsUsingContext(context.LoadSynchronous());
+}
+
+void ACustomPlayerController::OnAnyKeyPressed(FKey key)
+{
+    if(onAnyKeyPressed.IsBound())
+        onAnyKeyPressed.Broadcast(key);
+}
+
+void ACustomPlayerController::OnAnyKeyReleased(FKey key)
+{
+    if(onAnyKeyReleased.IsBound())
+        onAnyKeyReleased.Broadcast(key);
+}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CustomPlayerController.h

@@ -0,0 +1,49 @@
+// Oleg Petruny proprietary.
+
+#pragma once
+
+#include "GameFramework/PlayerController.h"
+
+#include "CustomPlayerController.generated.h"
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerAnyKeyPressedDelegate, FKey, key);
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerAnyKeyReleasedDelegate, FKey, key);
+
+/**
+ * De-facto wrapper/interface of all usefull shortcuts and automatization around input system.
+ * Append new input context here for auto init on BeginPlay and apply user input settings.
+ * Also, has delegates onAnyKeyPressed/Released.
+ */
+UCLASS()
+class ACustomPlayerController : public APlayerController
+{
+    GENERATED_BODY()
+
+public:
+    UFUNCTION(BlueprintPure, meta = (DisplayName = "GetCustomPlayerController"))
+    static ACustomPlayerController* Get() { return instance; }
+    UFUNCTION(BlueprintPure)
+    static class UEnhancedInputComponent* GetInput() { return input; }
+    UFUNCTION(BlueprintPure)
+    static class UEnhancedInputLocalPlayerSubsystem* GetInputSubsystem() { return subsystem; }
+
+    UFUNCTION(BlueprintCallable)
+    static void AppendInputContext(TSoftObjectPtr<class UInputMappingContext> context);
+
+    FPlayerAnyKeyPressedDelegate onAnyKeyPressed;
+    FPlayerAnyKeyReleasedDelegate onAnyKeyReleased;
+
+protected:
+    virtual void BeginPlay() override;
+
+private:
+    static void ApplyMouseSettings(TSoftObjectPtr<class UInputMappingContext>& context);
+
+    void OnAnyKeyPressed(FKey key);
+    void OnAnyKeyReleased(FKey key);
+
+    static ACustomPlayerController* instance;
+    static class UEnhancedInputLocalPlayerSubsystem* subsystem;
+    static class UEnhancedInputComponent* input;
+    static TSet<TSoftObjectPtr<class UInputMappingContext>> contexts;
+};

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/CutsceneManager.cpp

@@ -9,7 +9,7 @@
 #include "LevelSequence.h"
 #include "LevelSequencePlayer.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 #include "PlayerBase.h"
 #include "Widgets/CutsceneSkipWidget.h"
@@ -20,13 +20,7 @@ UCutsceneManager::UCutsceneManager()
 {
     static ConstructorHelpers::FObjectFinder<UInputMappingContext> asset{ TEXT("/Script/EnhancedInput.InputMappingContext'/Game/Input/IMC_Cutscene.IMC_Cutscene'") };
     _inputContext = asset.Object;
-    if(auto world = GetWorld())
-    {
-        if(auto GI = Cast<UCustomGameInstanceBase>(world->GetGameInstance()))
-        {
-            GI->inputContexts.Add(_inputContext);
-        }
-    }
+    ACustomPlayerController::AppendInputContext(_inputContext);
 }
 
 void UCutsceneManager::EnqueueSequence(ULevelSequence* sequence, FCutsceneEndCallback endCallback)
@@ -47,8 +41,9 @@ void UCutsceneManager::EnqueueSequence(ULevelSequence* sequence, FCutsceneEndCal
                 _lastPlayer->LockPlayer({ .walk = true, .jump = true, .run = true, .interaction = true, .camera = true });
 
                 auto& mapping = _inputContext.LoadSynchronous()->GetMapping(0);
-                int32 handler1 = _lastPlayer->inputComponent->BindAction(mapping.Action, ETriggerEvent::Started, this, &UCutsceneManager::OnInputHold).GetHandle();
-                int32 handler2 = _lastPlayer->inputComponent->BindAction(mapping.Action, ETriggerEvent::Completed, this, &UCutsceneManager::OnInputUnhold).GetHandle();
+                auto input = ACustomPlayerController::GetInput();
+                int32 handler1 = input->BindAction(mapping.Action, ETriggerEvent::Started, this, &UCutsceneManager::OnInputHold).GetHandle();
+                int32 handler2 = input->BindAction(mapping.Action, ETriggerEvent::Completed, this, &UCutsceneManager::OnInputUnhold).GetHandle();
                 _handlers = { handler1, handler2 };
 
                 if(auto WM = AMainGameModeBase::GetWidgetsManager())
@@ -151,8 +146,9 @@ void UCutsceneManager::OnSequenceEnd()
     {
         _lastPlayer->UnlockPlayer({ .walk = true, .jump = true, .run = true, .interaction = true, .camera = true });
 
-        _lastPlayer->inputComponent->RemoveBindingByHandle(_handlers.Key);
-        _lastPlayer->inputComponent->RemoveBindingByHandle(_handlers.Value);
+        auto input = ACustomPlayerController::GetInput();
+        input->RemoveBindingByHandle(_handlers.Key);
+        input->RemoveBindingByHandle(_handlers.Value);
 
         _lastPlayer = nullptr;
     }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/DialogueManager.cpp

@@ -11,7 +11,7 @@
 #include "Kismet/KismetMathLibrary.h"
 #include "Sound/SoundWave.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 #include "PlayerBase.h"
 #include "Widgets/DialogueSkipWidget.h"
@@ -22,13 +22,7 @@ UDialogueManager::UDialogueManager()
 {
     static ConstructorHelpers::FObjectFinder<UInputMappingContext> asset{ TEXT("/Script/EnhancedInput.InputMappingContext'/Game/Input/IMC_Dialogue.IMC_Dialogue'") };
     _inputContext = asset.Object;
-    if(auto world = GetWorld())
-    {
-        if(auto GI = Cast<UCustomGameInstanceBase>(world->GetGameInstance()))
-        {
-            GI->inputContexts.Add(_inputContext);
-        }
-    }
+    ACustomPlayerController::AppendInputContext(_inputContext);
 }
 
 void UDialogueManager::PlayDialogue(FDialogueEnqueProperties properties, FDialogueEndCallback endCallback)
@@ -99,7 +93,7 @@ void UDialogueManager::EnqueDialogue(FDialogueEnqueProperties properties, FDialo
             if(_lastPlayer)
             {
                 auto& mapping = _inputContext.LoadSynchronous()->GetMapping(0);
-                _inputHandler = _lastPlayer->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &UDialogueManager::OnInputPress).GetHandle();
+                _inputHandler = ACustomPlayerController::GetInput()->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &UDialogueManager::OnInputPress).GetHandle();
 
                 if(auto WM = AMainGameModeBase::GetWidgetsManager())
                 {
@@ -261,7 +255,7 @@ void UDialogueManager::OnDialogueEnd()
     _dialoguesLock.Lock();
     if(_endCallbacks.IsEmpty() && _lastPlayer)
     {
-        _lastPlayer->inputComponent->RemoveBindingByHandle(_inputHandler);
+        ACustomPlayerController::GetInput()->RemoveBindingByHandle(_inputHandler);
         _lastPlayer = nullptr;
     }
     _dialoguesLock.Unlock();

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/InCameraInteractableActivator.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "InCameraInteractableActivator.h"
 
 #include "CommonFunctions.h"
@@ -20,10 +19,10 @@ UInCameraInteractableActivator::UInCameraInteractableActivator(const FObjectInit
     activatorType = EActivatorType::Saw;
     scanDistance = 7000;
 
-    _capturer = CreateDefaultSubobject<UInteractableScreenCapturer>(TEXT("UInCameraInteractableActivator_UInteractableScreenCapturer"));
-    _capturer->interactableInScreenDelegate.BindUObject(this, &UInCameraInteractableActivator::NewSeenInteractable_Implementation);
-    _capturer->SetupAttachment(this);
-    _capturer->scanDistance = scanDistance;
+    capturer = CreateDefaultSubobject<UInteractableScreenCapturer>(TEXT("UInCameraInteractableActivator_UInteractableScreenCapturer"));
+    capturer->interactableInScreenDelegate.BindUObject(this, &UInCameraInteractableActivator::NewSeenInteractable);
+    capturer->SetupAttachment(this);
+    capturer->scanDistance = scanDistance;
 
     PrimaryComponentTick.bCanEverTick = true;
     PrimaryComponentTick.bStartWithTickEnabled = false;
@@ -31,27 +30,28 @@ UInCameraInteractableActivator::UInCameraInteractableActivator(const FObjectInit
 
 void UInCameraInteractableActivator::OnRegister()
 {
-    UInteractableActivator::OnRegister();
-    _capturer->RegisterComponent();
-    _capturer->Activate();
+    Super::OnRegister();
+    capturer->RegisterComponent();
+    capturer->Activate();
 }
 
-void UInCameraInteractableActivator::NewSeenInteractable_Implementation(AInteractable* interactable)
+void UInCameraInteractableActivator::NewSeenInteractable(AInteractable* interactable)
 {
-    _interactablesToActivate.Enqueue(interactable);
+    interactablesToActivate.Enqueue(interactable);
     SetComponentTickEnabled(true);
 }
 
 void UInCameraInteractableActivator::Scan_Implementation()
 {
     SetComponentTickEnabled(false);
-    while(!_interactablesToActivate.IsEmpty())
+    while(!interactablesToActivate.IsEmpty())
     {
         AInteractable* interactable;
-        _interactablesToActivate.Dequeue(interactable);
+        interactablesToActivate.Dequeue(interactable);
         if(interactableActivatedDelegate.IsBound())
         {
             interactableActivatedDelegate.Execute(interactable, activatorType);
+            OnNewSeenInteractable(interactable);
         }
     }
 }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/InCameraInteractableActivator.h

@@ -2,13 +2,14 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
-
 #include "InteractableActivator.h"
 
 #include "InCameraInteractableActivator.generated.h"
 
-UCLASS(Blueprintable, BlueprintType)
+/**
+ * Activates interactable only once if is in a camera view
+ */
+UCLASS(Blueprintable, BlueprintType, ClassGroup = InteractableActivator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Activates interactable only once if is in a camera view"), MinimalAPI)
 class UInCameraInteractableActivator : public UInteractableActivator
 {
     GENERATED_BODY()
@@ -19,14 +20,30 @@ public:
 protected:
     virtual void OnRegister() override;
 
+    virtual bool AutoInstantiateInPlayer() override { return true; }
+
+    /**
+     * Scan is performed independently by _capturer member object.
+     * This implementation just activates interactables in the game thread.
+     */
     virtual void Scan_Implementation() override;
 
-    UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
-    LOST_EDGE_API void NewSeenInteractable(class AInteractable* interactable);
-    virtual void NewSeenInteractable_Implementation(class AInteractable* interactable);
+    /**
+     * Thread safe enques interactable for activation in the next game tick
+     * @param interactable .. interactable to activate
+     */
+    UFUNCTION(BlueprintCallable)
+    void NewSeenInteractable(class AInteractable* interactable);
+
+    /**
+     * Called after interactable activation
+     * @param interactable .. interactable activated
+     */
+    UFUNCTION(BlueprintImplementableEvent)
+    void OnNewSeenInteractable(class AInteractable* interactable);
 
 private:
     UPROPERTY()
-    class UInteractableScreenCapturer* _capturer;
-    TQueue<class AInteractable*> _interactablesToActivate;
+    class UInteractableScreenCapturer* capturer;
+    TQueue<class AInteractable*> interactablesToActivate;
 };

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/InteractableActivator.cpp

@@ -1,12 +1,19 @@
 // Oleg Petruny proprietary.
 
-
 #include "InteractableActivator.h"
 
 #include "Engine/CollisionProfile.h"
 
+#include "Interactable/Interactable.h"
 #include "PlayerBase.h"
 
+void UInteractableActivator::OnRegister()
+{
+    Super::OnRegister();
+
+    AInteractable::AppendInteractableActivatorClass(GetClass());
+}
+
 UInteractableActivator::UInteractableActivator(const FObjectInitializer& ObjectInitializer)
     : USceneComponent(ObjectInitializer)
 {

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/InteractableActivator.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include "Components/SceneComponent.h"
-#include "CoreMinimal.h"
 
 #include "Interactable/Interactable.h"
 
@@ -12,23 +11,33 @@
 DECLARE_DELEGATE_TwoParams(FInteractableActivated, AInteractable*, EActivatorType);
 DECLARE_DELEGATE_TwoParams(FInteractableDeactivated, AInteractable*, EActivatorType);
 
-UCLASS(Abstract, Blueprintable, BlueprintType)
+/**
+ * Activates interactable based on type
+ */
+UCLASS(Abstract, Blueprintable, BlueprintType, ClassGroup = InteractableActivator, meta = (ShortTooltip = "Activates interactable based on type"), MinimalAPI)
 class UInteractableActivator : public USceneComponent
 {
     GENERATED_BODY()
 
 public:
+    /** Append itself to CustomGameInstance modificators registry */
+    virtual void OnRegister() override;
+
     UInteractableActivator(const FObjectInitializer& ObjectInitializer);
     virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
 
+    virtual bool AutoInstantiateInPlayer() { return false; }
+
+    /** Resets activator state forcing to rescan */
     UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
     LOST_EDGE_API void Rescan();
-    virtual void Rescan_Implementation() {}
+    virtual void Rescan_Implementation() PURE_VIRTUAL(UInteractableActivator::Scan_Implementation, );
 
     FInteractableActivated interactableActivatedDelegate;
     FInteractableActivated interactableDeactivatedDelegate;
 
 protected:
+    /** Activator scan function in game thread tick */
     UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
     LOST_EDGE_API void Scan();
     virtual void Scan_Implementation() PURE_VIRTUAL(UInteractableActivator::Scan_Implementation, );

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/InteractableScreenCapturer.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "InteractableScreenCapturer.h"
 
 #include "Engine/Texture.h"
@@ -16,9 +15,12 @@
 #include "Interactable/Interactable.h"
 #include "InteractableScreenCapturerBitMapCS.h"
 
-constexpr float tickInterval = 1.0f / 5;
-constexpr float textureWidth = 1280 / 2;
-constexpr float textureHeight = 720 / 2;
+namespace
+{
+    constexpr float tickInterval = 1.0f / 5;
+    constexpr float textureWidth = 1280 / 2;
+    constexpr float textureHeight = 720 / 2;
+}
 
 UInteractableScreenCapturer::UInteractableScreenCapturer(const FObjectInitializer& ObjectInitializer)
     : USceneCaptureComponent2D(ObjectInitializer)
@@ -85,7 +87,7 @@ void UInteractableScreenCapturer::TickComponent(float DeltaTime, enum ELevelTick
         {
             USceneCaptureComponent2D::TickComponent(DeltaTime, TickType, ThisTickFunction);
             CaptureScene();
-            GetCameraView(DeltaTime, _view);
+            GetCameraView(DeltaTime, view);
             Process();
         }
         break;
@@ -104,7 +106,7 @@ void UInteractableScreenCapturer::Process()
             [
                 capture = TextureTarget->GetResource()->TextureRHI,
                     world = GetWorld(),
-                    view = _view,
+                    view = view,
                     //output = _output->GetResource()->TextureRHI,
                     this
             ]
@@ -262,6 +264,7 @@ void UInteractableScreenCapturer::Process()
                                 AsyncTask(ENamedThreads::GameThread, [=, this]()
                                     {
                                         interactableInScreenDelegate.Execute(interactable);
+                                        OnInteractableInScreen(interactable);
                                     });
                             }
                         }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/InteractableScreenCapturer.h

@@ -9,7 +9,10 @@
 
 DECLARE_DELEGATE_OneParam(FInteractableInScreen, class AInteractable*);
 
-UCLASS(hidecategories = (Collision, Object, Physics, SceneComponent), ClassGroup = Rendering, editinlinenew, meta = (BlueprintSpawnableComponent), MinimalAPI)
+/**
+ * Notifies only once about interactable is in a camera view
+ */
+UCLASS(BlueprintType, hidecategories = (Collision, Object, Physics, SceneComponent), ClassGroup = Rendering, editinlinenew, meta = (BlueprintSpawnableComponent, ShortTooltip = "Notifies only once about interactable is in a camera view"), MinimalAPI)
 class UInteractableScreenCapturer : public USceneCaptureComponent2D
 {
     GENERATED_BODY()
@@ -19,15 +22,18 @@ public:
     virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
 
     FInteractableInScreen interactableInScreenDelegate;
+    UFUNCTION(BlueprintImplementableEvent)
+    void OnInteractableInScreen(class AInteractable* interactable);
 
     UPROPERTY(EditAnywhere)
     float scanDistance = 7000;
 
 protected:
+    /** Enques render thread task to find obect on screen  */
     void Process();
 
 private:
-    FMinimalViewInfo _view;
+    FMinimalViewInfo view; //!< Camera view cache
     TSet<class AInteractable*> _sawInteractables;
     //class UTextureRenderTarget2D* _output;
 };

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/RaycastInteractableActivator.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "RaycastInteractableActivator.h"
 
 #include "DrawDebugHelpers.h" 
@@ -14,12 +13,12 @@ URaycastInteractableActivator::URaycastInteractableActivator(const FObjectInitia
 
 void URaycastInteractableActivator::Rescan_Implementation()
 {
-    _last = nullptr;
+    lastInteractable = nullptr;
 }
 
 void URaycastInteractableActivator::Scan_Implementation()
 {
-    FHitResult result{};
+    FHitResult result;
     FVector startLocation = GetComponentLocation();
     FVector endLocation = startLocation + (GetComponentRotation().Vector() * scanDistance);
 
@@ -32,17 +31,17 @@ void URaycastInteractableActivator::Scan_Implementation()
 
     if(result.bBlockingHit)
     {
-        if(_last != result.GetActor())
+        if(lastInteractable != result.GetActor())
         {
-            if(_last)
+            if(lastInteractable)
             {
-                interactableDeactivatedDelegate.Execute(_last, activatorType);
-                _last = nullptr;
+                interactableDeactivatedDelegate.Execute(lastInteractable, activatorType);
+                lastInteractable = nullptr;
             }
-            _activated = true;
+            activated = true;
             if(auto interactable = Cast<AInteractable>(result.GetActor()))
             {
-                _last = interactable;
+                lastInteractable = interactable;
                 if(interactableActivatedDelegate.IsBound())
                 {
                     interactableActivatedDelegate.Execute(interactable, activatorType);
@@ -53,21 +52,21 @@ void URaycastInteractableActivator::Scan_Implementation()
 #ifdef INTERACTABLE_ACTIVATOR_DEBUG
         DrawDebugLine(GetWorld(), startLocation, endLocation, FColor::Green, false, PrimaryComponentTick.TickInterval, 0, 0.1f);
 #endif // INTERACTABLE_ACTIVATOR_DEBUG
-        }
+    }
     else
     {
-        if(_activated)
+        if(activated)
         {
             if(interactableDeactivatedDelegate.IsBound())
             {
-                interactableDeactivatedDelegate.Execute(_last, activatorType);
+                interactableDeactivatedDelegate.Execute(lastInteractable, activatorType);
             }
-            _activated = false;
-            _last = nullptr;
+            activated = false;
+            lastInteractable = nullptr;
         }
 
 #ifdef INTERACTABLE_ACTIVATOR_DEBUG
         DrawDebugLine(GetWorld(), startLocation, endLocation, FColor::Red, false, PrimaryComponentTick.TickInterval, 10, 0.1f);
 #endif // INTERACTABLE_ACTIVATOR_DEBUG
-        }
-    }
+    }
+}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Activators/RaycastInteractableActivator.h

@@ -2,12 +2,14 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
 #include "InteractableActivator.h"
 
 #include "RaycastInteractableActivator.generated.h"
 
-UCLASS(Blueprintable, BlueprintType)
+/**
+ * Activates interactable with a single raycast from a camera center
+ */
+UCLASS(Blueprintable, BlueprintType, ClassGroup = InteractableActivator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Activates interactable with a single raycast from a camera center"), MinimalAPI)
 class URaycastInteractableActivator : public UInteractableActivator
 {
     GENERATED_BODY()
@@ -15,12 +17,14 @@ class URaycastInteractableActivator : public UInteractableActivator
 public:
     URaycastInteractableActivator(const FObjectInitializer& ObjectInitializer);
 
+    virtual bool AutoInstantiateInPlayer() override { return true; }
+
     virtual void Rescan_Implementation() override;
 
 protected:
     virtual void Scan_Implementation() override;
 
 private:
-    class AInteractable* _last = nullptr;
-    bool _activated = false;
+    class AInteractable* lastInteractable = nullptr;
+    bool activated = false;
 };

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Interactable.cpp

@@ -1,15 +1,35 @@
 // Oleg Petruny proprietary.
 
-
 #include "Interactable.h"
 
 #include "Kismet/GameplayStatics.h"
 
+#include "Activators/InteractableActivator.h"
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 #include "Modificators/InteractableModificator.h"
 #include "PlayerBase.h"
 #include "Widgets/WidgetsManager.h"
 
+TSet<TSubclassOf<class UInteractableActivator>> AInteractable::interactionActivators = {};
+TSet<TSubclassOf<class UInteractableModificator>> AInteractable::interactionModificators = {};
+
+void AInteractable::AppendInteractableActivatorClass(TSubclassOf<class UInteractableActivator> activator)
+{
+    interactionActivators.Add(activator);
+}
+
+void AInteractable::AppendInteractableModificatorClass(TSubclassOf<class UInteractableModificator> modificator)
+{
+    bool alreadyPresent = false;
+    interactionModificators.Add(modificator, &alreadyPresent);
+    if(alreadyPresent)
+        return;
+
+    auto IC = modificator.GetDefaultObject()->GetMappingContext();
+    ACustomPlayerController::AppendInputContext(IC);
+}
+
 int32 AInteractable::GetActivatedFlags()
 {
     return activated;
@@ -86,13 +106,13 @@ void AInteractable::EndPlay(const EEndPlayReason::Type EndPlayReason)
     if(activated)
     {
         activationLockers.Empty();
-        _Deactivate(static_cast<EActivatorType>(activated));
+        Deactivate(static_cast<EActivatorType>(activated));
     }
 
     Super::EndPlay(EndPlayReason);
 }
 
-void AInteractable::_Activate(EActivatorType type)
+void AInteractable::Activate(EActivatorType type)
 {
 #ifdef INTERACTABLE_DEBUG
     GEngine->AddOnScreenDebugMessage(30 + (int)type, 5.0f, FColor::Cyan, TEXT("Player activate: ") + this->GetName()
@@ -113,7 +133,7 @@ void AInteractable::_Activate(EActivatorType type)
             if(static_cast<uint8>(modificator.Value->GetActivatorTypes()) & static_cast<uint8>(type))
             {
                 WM->ShowInteractionHints(modificator.Value);
-                modificator.Value->Bind(player->inputComponent);
+                modificator.Value->Bind(ACustomPlayerController::GetInput());
             }
         }
     }
@@ -127,7 +147,7 @@ void AInteractable::_Activate(EActivatorType type)
     Activate(type);
 }
 
-void AInteractable::_Deactivate(EActivatorType type)
+void AInteractable::Deactivate(EActivatorType type)
 {
 #ifdef INTERACTABLE_DEBUG
     GEngine->AddOnScreenDebugMessage(30 + (int)type, 5.0f, FColor::Magenta, TEXT("Player deactivate: ") + this->GetName()

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Interactable.h

@@ -2,15 +2,18 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
 #include "GameFramework/Actor.h"
 
 #include "Interactable.generated.h"
 
+/** Turns on debug of interactable objects */
 //#define INTERACTABLE_DEBUG
+/** Turns on debug of interactable activator components */
 //#define INTERACTABLE_ACTIVATOR_DEBUG
+/** Turns on debug of interactable modificator components */
 //#define INTERACTABLE_MODIFICATOR_DEBUG
 
+/** Defines activation types */
 UENUM(BlueprintType, meta = (Bitflags, UseEnumValuesAsMaskValuesInEditor = "true"))
 enum class EActivatorType : uint8
 {
@@ -27,38 +30,61 @@ enum class EActivatorType : uint8
 };
 ENUM_CLASS_FLAGS(EActivatorType);
 
+/**
+ * Object capable of reacting to activators and execute modificators.
+ * Sets all needed settings as collision layers on begin play.
+ */
 UCLASS(Blueprintable, BlueprintType, MinimalAPI)
 class AInteractable : public AActor
 {
     GENERATED_BODY()
 
 public:
+    static void AppendInteractableActivatorClass(TSubclassOf<class UInteractableActivator> activator);
+    static void AppendInteractableModificatorClass(TSubclassOf<class UInteractableModificator> modificator);
+
+    /** Interactables shared cache */
+    static TSet<TSubclassOf<class UInteractableActivator>> interactionActivators;
+    static TSet<TSubclassOf<class UInteractableModificator>> interactionModificators;
+
+public:
+
+    /** Returns flags mask of activated types */
     int32 GetActivatedFlags();
 
-    void _Activate(EActivatorType type);
-    UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
+    /** Receives activate signal from activator of specific type and activates all modificators of that type */
+    UFUNCTION(BlueprintCallable)
     void Activate(EActivatorType type);
-    virtual void Activate_Implementation(EActivatorType type) {}
 
-    void _Deactivate(EActivatorType type);
-    UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
+    /** Receives deactivate signal from activator of specific type and deactivates all modificators of that type */
+    UFUNCTION(BlueprintCallable)
     void Deactivate(EActivatorType type);
-    virtual void Deactivate_Implementation(EActivatorType type) {}
 
+    /**
+     * All modificators that requires (de)activation lock for current interactable.
+     * Used manually by modificators to handle operations which can be continued after physical deactivation.
+     * Eg. MoveModificator movement while mouse buttons are down even if player don't activating interactable anymore.
+     */
     TSet<class UInteractableModificator*> activationLockers;
 
 protected:
     virtual void BeginPlay() override;
     virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
+    UFUNCTION(BlueprintImplementableEvent)
+    void OnActivate(EActivatorType type);
+    UFUNCTION(BlueprintImplementableEvent)
+    void OnDeactivate(EActivatorType type);
+
+    /** Mask of active activator types */
     UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (Bitmask, BitmaskEnum = "EActivatorType"))
     int32 activated = 0;
 
+    /** Map of modificators to activator types initialized on BeginPlay */
     UPROPERTY()
     TMap<EActivatorType, class UInteractableModificator*> modificators;
 
-    class APlayerBase* player = nullptr;
     TArray<UPrimitiveComponent*> collisions;
-
+    class APlayerBase* player = nullptr;
 };
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/ActivateInteractableModificator.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "ActivateInteractableModificator.h"
 
 #include "EnhancedInputComponent.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/ActivateInteractableModificator.h

@@ -2,14 +2,16 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
 #include "InteractableModificator.h"
 
 #include "ActivateInteractableModificator.generated.h"
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FActivateInteractableModificatorActivatedDelegate);
 
-UCLASS(ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent), Blueprintable, BlueprintType)
+/**
+ * Basic modificator for type Use
+ */
+UCLASS(Blueprintable, BlueprintType, ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Basic modificator for type Use"), MinimalAPI)
 class UActivateInteractableModificator : public UInteractableModificator
 {
     GENERATED_BODY()

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/EditInteractableModificator.cpp

@@ -1,14 +1,11 @@
 // Oleg Petruny proprietary.
 
-
 #include "EditInteractableModificator.h"
 
 #include "Interactable/Interactable.h"
 
-UEditInteractableModificator::UEditInteractableModificator(const FObjectInitializer& ObjectInitializer)
-    : UInteractableModificator(ObjectInitializer)
-{
-    activatorTypes |= static_cast<uint8>(EActivatorType::Collide);
-
-
-}
+//UEditInteractableModificator::UEditInteractableModificator(const FObjectInitializer& ObjectInitializer)
+//    : UInteractableModificator(ObjectInitializer)
+//{
+//    activatorTypes |= static_cast<uint8>(EActivatorType::Collide);
+//}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/EditInteractableModificator.h

@@ -2,17 +2,20 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
 #include "InteractableModificator.h"
 
-#include "EditInteractableModificator.generated.h"
+//#include "EditInteractableModificator.generated.h"
 
-UCLASS(ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent), Blueprintable, BlueprintType)
-class UEditInteractableModificator : public UInteractableModificator
-{
-    GENERATED_BODY()
-
-public:
-    UEditInteractableModificator(const FObjectInitializer& ObjectInitializer);
-
-};
+/**
+ * <WIP>
+ * Edits object topology on collision
+ */
+ //UCLASS(Blueprintable, BlueprintType, ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Edits object topology on collision"), MinimalAPI)
+ //class UEditInteractableModificator : public UInteractableModificator
+ //{
+ //    GENERATED_BODY()
+ //
+ //public:
+ //    UEditInteractableModificator(const FObjectInitializer& ObjectInitializer);
+ //
+ //};

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/InteractableModificator.cpp

@@ -1,29 +1,20 @@
 // Oleg Petruny proprietary.
 
-
 #include "InteractableModificator.h"
 
-#include "InputMappingContext.h"
-
-#include "CustomGameInstanceBase.h"
+#include "Interactable/Interactable.h"
 #include "Widgets/InteractableHintWidget.h"
 
 void UInteractableModificator::OnRegister()
 {
     UActorComponent::OnRegister();
 
-    if(auto world = GetWorld())
-    {
-        if(auto GI = Cast<UCustomGameInstanceBase>(world->GetGameInstance()))
-        {
-            GI->AppendInteractableModificatorClass(this->GetClass());
-        }
-    }
+    AInteractable::AppendInteractableModificatorClass(GetClass());
 }
 
-const UInputMappingContext* UInteractableModificator::GetMappingContext() const
+const TSoftObjectPtr<class UInputMappingContext> UInteractableModificator::GetMappingContext() const
 {
-    return inputMapping.LoadSynchronous();
+    return inputMapping;
 }
 
 EActivatorType UInteractableModificator::GetActivatorTypes() const

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/InteractableModificator.h

@@ -3,29 +3,37 @@
 #pragma once
 
 #include "Components/ActorComponent.h"
-#include "CoreMinimal.h"
 
 #include "InteractableModificator.generated.h"
 
 enum class EActivatorType : uint8;
 
-UCLASS(Abstract, Blueprintable, BlueprintType)
+/**
+ * Do something on activation by specified activator types
+ */
+UCLASS(Abstract, Blueprintable, BlueprintType, ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Do something on activation by specified activator types"), MinimalAPI)
 class UInteractableModificator : public UActorComponent
 {
     GENERATED_BODY()
 
 public:
-    void OnRegister() override;
+    /** Append itself to CustomGameInstance modificators registry */
+    virtual void OnRegister() override;
 
+    /** Returns input mappings assigned in constructor */
     UFUNCTION(BlueprintCallable)
-    const class UInputMappingContext* GetMappingContext() const;
+    const TSoftObjectPtr<class UInputMappingContext> GetMappingContext() const;
+
+    /** Filters activation type in interractable */
     UFUNCTION(BlueprintCallable)
     EActivatorType GetActivatorTypes() const;
 
+    /** Called from interactable on activation (mostly used to bind input context to internal modificator functions) */
     UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
     void Bind(class UEnhancedInputComponent* input);
     virtual void Bind_Implementation(class UEnhancedInputComponent* input) {}
 
+    /** Called from interactable on deactivation (mostly used to unbind input context from internal functions) */
     UFUNCTION(BlueprintNativeEvent, BlueprintCallable)
     void Unbind();
     virtual void Unbind_Implementation() {}

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/InventoryInteractableModificator.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "InventoryInteractableModificator.h"
 
 #include "EnhancedInputComponent.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/InventoryInteractableModificator.h

@@ -2,12 +2,14 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
 #include "InteractableModificator.h"
 
 #include "InventoryInteractableModificator.generated.h"
 
-UCLASS(ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent), Blueprintable, BlueprintType)
+/**
+ * Modificator of type Use for storing items in a APlayerBase
+ */
+UCLASS(Blueprintable, BlueprintType, ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Modificator of type Use for storing items in a APlayerBase"), MinimalAPI)
 class UInventoryInteractableModificator : public UInteractableModificator
 {
     GENERATED_BODY()

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/MoveInteractableModificator.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "MoveInteractableModificator.h"
 
 #include "EnhancedInputComponent.h"
@@ -90,7 +89,7 @@ void UMoveInteractableModificator::Unbind_Implementation()
     bindindingHandlers.Empty();
 
     SetComponentTickEnabled(false);
-    actor->_Deactivate(GetActivatorTypes());
+    actor->Deactivate(GetActivatorTypes());
 
     OnMoveDeactivated.Broadcast();
 }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/MoveInteractableModificator.h

@@ -2,7 +2,6 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
 #include "InputActionValue.h"
 #include "InteractableModificator.h"
 
@@ -13,7 +12,10 @@ DECLARE_DYNAMIC_MULTICAST_DELEGATE(FDeactivateMoveInteractableModificatorActivat
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FHoldingMoveInteractableModificatorActivatedDelegate);
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FRotatingMoveInteractableModificatorActivatedDelegate);
 
-UCLASS(ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent), Blueprintable, BlueprintType)
+/**
+ * Basic modificator for Move type activator
+ */
+UCLASS(Blueprintable, BlueprintType, ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Basic modificator for Move type activator"), MinimalAPI)
 class UMoveInteractableModificator : public UInteractableModificator
 {
     GENERATED_BODY()

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/SawInteractableModificator.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "SawInteractableModificator.h"
 
 #include "Interactable/Interactable.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Interactable/Modificators/SawInteractableModificator.h

@@ -2,14 +2,16 @@
 
 #pragma once
 
-#include "CoreMinimal.h"
 #include "InteractableModificator.h"
 
 #include "SawInteractableModificator.generated.h"
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FSawInteractableModificatorActivatedDelegate);
 
-UCLASS(ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent), Blueprintable, BlueprintType)
+/**
+ * Basic modificator for Saw type activator
+ */
+UCLASS(Blueprintable, BlueprintType, ClassGroup = InteractableModificator, meta = (BlueprintSpawnableComponent, ShortTooltip = "Basic modificator for Saw type activator"), MinimalAPI)
 class USawInteractableModificator : public UInteractableModificator
 {
     GENERATED_BODY()

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/Checkpoint.cpp

@@ -1,12 +1,11 @@
 // Oleg Petruny proprietary.
 
-
 #include "Checkpoint.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomGameInstance.h"
 
 void ACheckpoint::SaveGame()
 {
-    if(auto GI = Cast<UCustomGameInstanceBase>(GetWorld()->GetGameInstance()))
+    if(auto GI = UCustomGameInstance::GetGameInstance())
         GI->SaveGame(GetFName());
 }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/Checkpoint.h

@@ -6,6 +6,7 @@
 
 #include "Checkpoint.generated.h"
 
+/** Simple actor for game save */
 UCLASS(Blueprintable, BlueprintType, MinimalAPI)
 class ACheckpoint : public AActor
 {

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/Level1.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "Level1.h"
 
 #include "Atmosphere/AtmosphericFog.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/Level2.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "Level2.h"
 
 void ALevel2::BeginPlay()

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/Level3.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "Level3.h"
 
 #include "Atmosphere/AtmosphericFog.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/Level4.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "Level4.h"
 
 #include "Atmosphere/AtmosphericFog.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/Level5.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "Level5.h"
 
 #include "Atmosphere/AtmosphericFog.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/LevelBase.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "LevelBase.h"
 
 #include "Engine/StaticMesh.h"
@@ -11,7 +10,8 @@
 #include "LevelSequencePlayer.h"
 
 #include "CommonFunctions.h"
-#include "CustomGameInstanceBase.h"
+#include "CustomGameInstance.h"
+#include "CustomPlayerController.h"
 #include "Interactable/Interactable.h"
 #include "Levels/Checkpoint.h"
 #include "MainGameModeBase.h"
@@ -23,17 +23,6 @@ void ALevelBase::BeginPlay()
 {
     AMainGameModeBase::leadLevel = TStrongObjectPtr<ALevelBase>{ this };
 
-    if(auto world = GetWorld())
-    {
-        if(auto GI = Cast<UCustomGameInstanceBase>(world->GetGameInstance()))
-        {
-            for(TActorIterator<AMinigame> it(GetWorld()); it; ++it)
-            {
-                GI->inputContexts.Add(it->GetInputMappings());
-            }
-        }
-    }
-
     ALevelScriptActor::BeginPlay();
 
     BroadcastNewLevelBeginPlay();
@@ -62,7 +51,7 @@ void ALevelBase::IterateToState(int32 to)
 
 void ALevelBase::BroadcastNewLevelBeginPlay()
 {
-    if(auto GI = Cast<UCustomGameInstanceBase>(GetWorld()->GetGameInstance()))
+    if(auto GI = UCustomGameInstance::GetGameInstance())
         GI->OnLevelBeginned.Broadcast(GetFName());
 }
 
@@ -83,7 +72,7 @@ void ALevelBase::StartLevelAnimations()
 
 void ALevelBase::ApplySaveData()
 {
-    auto GI = UCustomGameInstanceBase::GetGameInstance();
+    auto GI = UCustomGameInstance::GetGameInstance();
     if(!GI || !GI->saveData || GI->saveData->level != GetWorld()->GetFName())
         return;
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Levels/LevelBase.h

@@ -6,15 +6,24 @@
 
 #include "LevelBase.generated.h"
 
+/**
+ * Expands basic UE level script actor.
+ * Has int type level states and events.
+ * Brodcasts level instantiation by CustomGameInstance::OnLevelBeginned(FName).
+ * On BeginPlay applies last save data if valid,
+ * and instantiate all sequencers from array onBeginPlaySequences.
+ */
 UCLASS(BlueprintType)
 class ALevelBase : public ALevelScriptActor
 {
     GENERATED_BODY()
 
 public:
+    /** Iterates throught level states */
     UFUNCTION(BlueprintCallable)
     inline void CallNextState() { ++state; NextState(); }
 
+    /** Calls specific event id in level */
     UFUNCTION(BlueprintImplementableEvent)
     void CallEvent(int32 id);
 
@@ -23,9 +32,11 @@ public:
 protected:
     virtual void BeginPlay() override;
 
+    /** Notifies level to process current state */
     UFUNCTION(BlueprintImplementableEvent)
     void NextState();
 
+    /** Shortcut for iterating from current to expected state */
     UFUNCTION(BlueprintCallable)
     void IterateToState(int32 to);
 
@@ -33,12 +44,13 @@ protected:
     void StartLevelAnimations();
     void ApplySaveData();
 
+    /** List of level animations for instantiation on level BeginPlay */
     UPROPERTY(EditDefaultsOnly)
     TArray<TSoftObjectPtr<class ULevelSequence>> onBeginPlaySequences;
+    /** Cache of actors that hold instantiated animations on BeginPlay */
     TArray<class ALevelSequenceActor*> onBeginPlaySequencesActors;
 
+    /** Current state of level */
     UPROPERTY(BlueprintReadOnly)
     int32 state = -1;
-    UPROPERTY(EditDefaultsOnly)
-    TArray<TSoftObjectPtr<class ULevelSequence>> stateSequences;
 };

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/MainGameModeBase.cpp

@@ -8,7 +8,7 @@
 #include "Kismet/GameplayStatics.h"
 #include "UObject/ScriptInterface.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomGameInstance.h"
 #include "CutsceneManager.h"
 #include "DialogueManager.h"
 #include "Levels/LevelBase.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/AgeOfWar/AgeOfWarManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "AgeOfWarManager.h"
 
 #include "Camera/CameraComponent.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/AgeOfWar/AgeOfWarUnit.cpp

@@ -1,12 +1,11 @@
 // Oleg Petruny proprietary.
 
-
 #include "AgeOfWarUnit.h"
 
+#include "Components/BoxComponent.h"
 #include "Components/StaticMeshComponent.h"
 
 #include "AgeOfWarManager.h"
-#include <Components/BoxComponent.h>
 
 namespace
 {

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/CrossyRoad/CrossyRoadManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "CrossyRoadManager.h"
 
 #include "Camera/CameraComponent.h"
@@ -10,7 +9,7 @@
 #include "InputMappingContext.h"
 
 #include "CrossyRoadObstacle.h"
-#include "CustomGameInstanceBase.h"
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 #include "PlayerBase.h"
 #include "Widgets/WidgetsManager.h"
@@ -19,7 +18,7 @@ ACrossyRoadManager::ACrossyRoadManager()
     : AMinigame()
 {
     static ConstructorHelpers::FObjectFinder<UInputMappingContext> asset{ TEXT("/Script/EnhancedInput.InputMappingContext'/Game/Input/Minigame/IMC_Minigame_CrossyRoad.IMC_Minigame_CrossyRoad'") };
-    input = asset.Object;
+    context = asset.Object;
 
     auto root = CreateDefaultSubobject<USceneComponent>(TEXT("Scene"));
 
@@ -43,16 +42,17 @@ void ACrossyRoadManager::Start(APlayerBase* playerPawn, FMinigameEndCallback del
     player->LockPlayer(FPlayerLock::All());
     player->SwitchToView(this);
 
-    for(auto& mapping : input.LoadSynchronous()->GetMappings())
+    auto input = ACustomPlayerController::GetInput();
+    for(auto& mapping : context.LoadSynchronous()->GetMappings())
     {
         if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Up"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Up).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Up).GetHandle());
         else if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Down"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Down).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Down).GetHandle());
         else if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Left"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Left).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Left).GetHandle());
         else if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Right"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Right).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ACrossyRoadManager::Right).GetHandle());
     }
 
     playerPos->SetWorldLocation(lines[0]->GetLocationAtTime(lines[0]->Duration * playerLineTime, ESplineCoordinateSpace::World));
@@ -70,7 +70,7 @@ void ACrossyRoadManager::End()
     PrimaryActorTick.SetTickFunctionEnable(false);
 
     for(int32 handler : inputHandlers)
-        player->inputComponent->RemoveBindingByHandle(handler);
+        ACustomPlayerController::GetInput()->RemoveBindingByHandle(handler);
 
     player->UnlockPlayer(FPlayerLock::All());
     player->ReturnPlayerView();

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/CrossyRoad/CrossyRoadObstacle.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "CrossyRoadObstacle.h"
 
 #include "CrossyRoadManager.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/Fishing/FishingManager.cpp

@@ -1,18 +1,18 @@
 // Oleg Petruny proprietary.
 
-
 #include "FishingManager.h"
 
 #include "EnhancedInputComponent.h"
 #include "InputMappingContext.h"
 
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 #include "PlayerBase.h"
 
 AFishingManager::AFishingManager()
 {
     static ConstructorHelpers::FObjectFinder<UInputMappingContext> asset{ TEXT("/Script/EnhancedInput.InputMappingContext'/Game/Input/Minigame/IMC_Minigame_Fishing.IMC_Minigame_Fishing'") };
-    input = asset.Object;
+    context = asset.Object;
 }
 
 void AFishingManager::Start(APlayerBase* playerPawn, FMinigameEndCallback delegate)
@@ -24,15 +24,17 @@ void AFishingManager::Start(APlayerBase* playerPawn, FMinigameEndCallback delega
 
     player->LockPlayer(FPlayerLock::All());
 
-    auto& mapping = input.LoadSynchronous()->GetMapping(0);
-    handler1 = player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Started, this, &AFishingManager::OnInputHold).GetHandle();
-    handler2 = player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Completed, this, &AFishingManager::OnInputUnhold).GetHandle();
+    auto input = ACustomPlayerController::GetInput();
+    auto& mapping = context.LoadSynchronous()->GetMapping(0);
+    handler1 = input->BindAction(mapping.Action, ETriggerEvent::Started, this, &AFishingManager::OnInputHold).GetHandle();
+    handler2 = input->BindAction(mapping.Action, ETriggerEvent::Completed, this, &AFishingManager::OnInputUnhold).GetHandle();
 }
 
 void AFishingManager::End()
 {
-    player->inputComponent->RemoveBindingByHandle(handler1);
-    player->inputComponent->RemoveBindingByHandle(handler2);
+    auto input = ACustomPlayerController::GetInput();
+    input->RemoveBindingByHandle(handler1);
+    input->RemoveBindingByHandle(handler2);
 
     player->UnlockPlayer(FPlayerLock::All());
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/Minigame.cpp

@@ -1,11 +1,8 @@
 // Oleg Petruny proprietary.
 
-
 #include "Minigame.h"
 
-#include "EnhancedInputSubsystems.h"
-#include "InputMappingContext.h"
-
+#include "CustomPlayerController.h"
 #include "PlayerBase.h"
 
 AMinigame::AMinigame()
@@ -22,23 +19,13 @@ void AMinigame::End()
     OnEnd();
 }
 
-void AMinigame::Restart()
-{}
-
-UInputMappingContext* AMinigame::GetInputMappings()
-{
-    return input.LoadSynchronous();
-}
-
 void AMinigame::Start(APlayerBase* playerPawn, FMinigameEndCallback delegate)
 {
     player = playerPawn;
     callback = delegate;
 
-    if(input)
-        if(auto PC = Cast<APlayerController>(playerPawn->GetController()))
-            if(auto inputSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PC->GetLocalPlayer()))
-                inputSubsystem->AddMappingContext(input.LoadSynchronous(), 0);
+    if(context.IsValid())
+        ACustomPlayerController::AppendInputContext(context);
 
     OnStart();
 }

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/Minigame.h

@@ -15,7 +15,14 @@ enum class EMinigameResult : uint8
 
 DECLARE_DYNAMIC_DELEGATE_TwoParams(FMinigameEndCallback, EMinigameResult, result, int32, score);
 
-UCLASS(Blueprintable, BlueprintType, MinimalAPI, Abstract)
+/**
+ * Interface for all minigame classes.
+ * Any minigame is started/ended/restarted by executing Start()/End()/Restart() on specific instance.
+ * Each call is after broadcasted into a blueprint event also.
+ * On start the caller can pass a OnEndCallback delegate to receive result and score on a minigame end.
+ * Each minigame can have its own contextInput
+ */
+UCLASS(Abstract, Blueprintable, BlueprintType, MinimalAPI)
 class AMinigame : public AActor
 {
     GENERATED_BODY()
@@ -25,21 +32,21 @@ public:
 
     UFUNCTION(BlueprintCallable)
     virtual void Start(class APlayerBase* playerPawn, FMinigameEndCallback delegate);
-
     UFUNCTION(BlueprintImplementableEvent)
     void OnStart();
 
     UFUNCTION(BlueprintCallable)
     virtual void End();
-
-    UFUNCTION(BlueprintCallable)
-    virtual void Restart();
-
     UFUNCTION(BlueprintImplementableEvent)
     void OnEnd();
 
+    UFUNCTION(BlueprintCallable)
+    virtual void Restart() {}
+    UFUNCTION(BlueprintImplementableEvent)
+    void OnRestart();
+
     UFUNCTION(BlueprintPure)
-    class UInputMappingContext* GetInputMappings();
+    TSoftObjectPtr<class UInputMappingContext> GetInputMappings() { return context; }
 
 protected:
     FMinigameEndCallback callback;
@@ -55,6 +62,6 @@ protected:
     bool ended = false;
 
     UPROPERTY(EditDefaultsOnly, BlueprintReadOnly)
-    TSoftObjectPtr<class UInputMappingContext> input = nullptr;
+    TSoftObjectPtr<class UInputMappingContext> context = nullptr;
 };
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/RythmClick/RythmClickManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "RythmClickManager.h"
 
 #include "MainGameModeBase.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/SubwaySurf/SubwaySurfManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "SubwaySurfManager.h"
 
 #include "Camera/CameraComponent.h"
@@ -9,7 +8,7 @@
 #include "EnhancedInputComponent.h"
 #include "InputMappingContext.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 #include "PlayerBase.h"
 #include "SubwaySurfObstacle.h"
@@ -19,7 +18,7 @@ ASubwaySurfManager::ASubwaySurfManager()
     : AMinigame()
 {
     static ConstructorHelpers::FObjectFinder<UInputMappingContext> asset{ TEXT("/Script/EnhancedInput.InputMappingContext'/Game/Input/Minigame/IMC_Minigame_SubwaySurf.IMC_Minigame_SubwaySurf'") };
-    input = asset.Object;
+    context = asset.Object;
 
     auto root = CreateDefaultSubobject<USceneComponent>(TEXT("Scene"));
 
@@ -43,16 +42,17 @@ void ASubwaySurfManager::Start(APlayerBase* playerPawn, FMinigameEndCallback del
     player->LockPlayer(FPlayerLock::All());
     player->SwitchToView(this);
 
-    for(auto& mapping : input.LoadSynchronous()->GetMappings())
+    auto input = ACustomPlayerController::GetInput();
+    for(auto& mapping : context.LoadSynchronous()->GetMappings())
     {
         if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Up"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Up).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Up).GetHandle());
         else if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Down"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Down).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Down).GetHandle());
         else if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Left"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Left).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Left).GetHandle());
         else if(mapping.Action->ActionDescription.EqualTo(FText::AsCultureInvariant(TEXT("Right"))))
-            inputHandlers.Add(player->inputComponent->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Right).GetHandle());
+            inputHandlers.Add(input->BindAction(mapping.Action, ETriggerEvent::Triggered, this, &ASubwaySurfManager::Right).GetHandle());
     }
 
     playerPos->SetRelativeLocation(lines[1]->GetLocationAtTime(lines[1]->Duration * 0.01f, ESplineCoordinateSpace::Local));
@@ -66,7 +66,7 @@ void ASubwaySurfManager::End()
     PrimaryActorTick.SetTickFunctionEnable(false);
 
     for(int32 handler : inputHandlers)
-        player->inputComponent->RemoveBindingByHandle(handler);
+        ACustomPlayerController::GetInput()->RemoveBindingByHandle(handler);
 
     player->UnlockPlayer(FPlayerLock::All());
     player->ReturnPlayerView();

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Minigame/SubwaySurf/SubwaySurfObstacle.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "SubwaySurfObstacle.h"
 
 #include "SubwaySurfManager.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/PlayerBase.cpp

@@ -4,16 +4,14 @@
 #include "PlayerBase.h"
 
 #include "Camera/CameraComponent.h"
-#include "EnhancedInputComponent.h"
-#include "EnhancedInputSubsystems.h"
 #include "GameFramework/CharacterMovementComponent.h"
 #include "GameFramework/SpringArmComponent.h"
 #include "InputMappingContext.h"
 #include "Kismet/GameplayStatics.h"
 #include "Kismet/KismetMathLibrary.h"
 
-#include "CustomGameInstanceBase.h"
 #include "CustomGameUserSettings.h"
+#include "CustomPlayerController.h"
 #include "Interactable/Activators/InteractableActivator.h"
 #include "Interactable/Interactable.h"
 #include "Interactable/Modificators/InteractableModificator.h"
@@ -84,44 +82,9 @@ void APlayerBase::BeginPlay()
         camera->PostProcessSettings.MotionBlurAmount = gameSettings->bUseMotionBlur ? 1.0f : 0.0f;
     }
 
-    playerController = Cast<APlayerController>(GetController());
-    if(playerController)
-    {
-        if(auto inputSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(playerController->GetLocalPlayer()))
-        {
-            if(auto GI = Cast<UCustomGameInstanceBase>(GetWorld()->GetGameInstance()))
-            {
-                inputSubsystem->ClearAllMappings();
-                for(auto& inputContext : GI->inputContexts)
-                {
-                    inputSubsystem->AddMappingContext(inputContext.LoadSynchronous(), 0);
-                }
-            }
-        }
-
-        inputComponent = Cast<UEnhancedInputComponent>(playerController->InputComponent);
-        if(inputComponent)
-        {
-            ((UInputComponent*)inputComponent)->BindAction(TEXT("AnyKey"), IE_Pressed, this, &APlayerBase::OnAnyKeyPressed);
-            ((UInputComponent*)inputComponent)->BindAction(TEXT("AnyKey"), IE_Released, this, &APlayerBase::OnAnyKeyReleased);
-        }
-    }
-
     LoadInteractablesActivators();
 }
 
-void APlayerBase::OnAnyKeyPressed(FKey key)
-{
-    if(onAnyKeyPressedDelegate.IsBound())
-        onAnyKeyPressedDelegate.Broadcast(key);
-}
-
-void APlayerBase::OnAnyKeyReleased(FKey key)
-{
-    if(onAnyKeyReleasedDelegate.IsBound())
-        onAnyKeyReleasedDelegate.Broadcast(key);
-}
-
 bool APlayerBase::IsMoving()
 {
     return bIsMoving;
@@ -257,22 +220,19 @@ void APlayerBase::UpdatePitch(float min, float max)
 
 void APlayerBase::LoadInteractablesActivators()
 {
-    if(auto GI = Cast<UCustomGameInstanceBase>(GetWorld()->GetGameInstance()))
+    TSet<UClass*> instancedActivators;
+    for(auto& act : AInteractable::interactionActivators)
     {
-        TSet<UClass*> instancedActivators;
-        for(auto& act : GI->interactionsActivators)
-        {
-            if(instancedActivators.Contains(act))
-                continue;
-            instancedActivators.Add(act);
+        if(instancedActivators.Contains(act))
+            continue;
+        instancedActivators.Add(act);
 
-            auto component = NewObject<UInteractableActivator>(this, act);
-            component->interactableActivatedDelegate.BindUObject(this, &APlayerBase::InteractableActivated);
-            component->interactableDeactivatedDelegate.BindUObject(this, &APlayerBase::InteractableDeactivated);
-            component->SetupAttachment(camera);
-            component->RegisterComponent();
-            interactableActivators.Add(component);
-        }
+        auto component = NewObject<UInteractableActivator>(this, act);
+        component->interactableActivatedDelegate.BindUObject(this, &APlayerBase::InteractableActivated);
+        component->interactableDeactivatedDelegate.BindUObject(this, &APlayerBase::InteractableDeactivated);
+        component->SetupAttachment(camera);
+        component->RegisterComponent();
+        interactableActivators.Add(component);
     }
 }
 
@@ -284,7 +244,7 @@ void APlayerBase::InteractableActivated(AInteractable* interactable, EActivatorT
     if(interactionLocked || interactable->IsHidden())
         return;
 
-    interactable->_Activate(type);
+    interactable->Activate(type);
 
     if(interactable != lastInteractable)
         lastInteractable = interactable;
@@ -295,7 +255,7 @@ void APlayerBase::InteractableDeactivated(AInteractable* interactable, EActivato
     if(!interactable)
         return;
 
-    interactable->_Deactivate(type);
+    interactable->Deactivate(type);
 
     if(interactable->GetActivatedFlags() == 0)
         lastInteractable = nullptr;

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/PlayerBase.h

@@ -8,8 +8,6 @@
 
 enum class EActivatorType : uint8;
 
-DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerAnyKeyPressedDelegate, FKey, key);
-DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPlayerAnyKeyReleasedDelegate, FKey, key);
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPlayerMovedDelegate);
 
 USTRUCT(BlueprintType)
@@ -66,20 +64,12 @@ public:
     FPlayerMovedDelegate OnPlayerMoved;
     FVector moveVector;
 
-    FPlayerAnyKeyPressedDelegate onAnyKeyPressedDelegate;
-    FPlayerAnyKeyReleasedDelegate onAnyKeyReleasedDelegate;
-
-    class UEnhancedInputComponent* inputComponent = nullptr;
-
     class AActor* leftPocketItem = nullptr;
     class AActor* rightPocketItem = nullptr;
 
 protected:
     virtual void BeginPlay() override;
 
-    void OnAnyKeyPressed(FKey key);
-    void OnAnyKeyReleased(FKey key);
-
     UFUNCTION(BlueprintCallable, Category = CameraMode)
     void SwitchToCameraPawn();
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/QuickTimeEvent.cpp

@@ -6,6 +6,7 @@
 #include "Kismet/GameplayStatics.h"
 
 #include "CommonFunctions.h"
+#include "CustomPlayerController.h"
 #include "MainGameModeBase.h"
 #include "PlayerBase.h"
 #include "Widgets/WidgetsManager.h"
@@ -84,10 +85,10 @@ void UQuickTimeEventManager::OnEventEnd(int32 id, EQuickTimeEventResult result)
 
     if(_events.IsEmpty())
     {
-        if(auto player = UCommonFunctions::GetPlayer(this))
+        if(auto PC = ACustomPlayerController::Get())
         {
-            player->onAnyKeyPressedDelegate.RemoveDynamic(this, &UQuickTimeEventManager::OnInputPressed);
-            player->onAnyKeyReleasedDelegate.RemoveDynamic(this, &UQuickTimeEventManager::OnInputReleased);
+            PC->onAnyKeyPressed.RemoveDynamic(this, &UQuickTimeEventManager::OnInputPressed);
+            PC->onAnyKeyReleased.RemoveDynamic(this, &UQuickTimeEventManager::OnInputReleased);
         }
         UCommonFunctions::ExitSlowMotion();
     }
@@ -153,12 +154,12 @@ void UQuickTimeEventManager::OnFirstEventInit()
 {
     if(_events.IsEmpty())
     {
-        if(auto player = UCommonFunctions::GetPlayer(this))
+        if(auto PC = ACustomPlayerController::Get())
         {
-            GetWorld()->GetTimerManager().SetTimerForNextTick([manager = this, player = player]()
+            GetWorld()->GetTimerManager().SetTimerForNextTick([=, this]()
                 {
-                    player->onAnyKeyPressedDelegate.AddDynamic(manager, &UQuickTimeEventManager::OnInputPressed);
-                    player->onAnyKeyReleasedDelegate.AddDynamic(manager, &UQuickTimeEventManager::OnInputReleased);
+                    PC->onAnyKeyPressed.AddDynamic(this, &UQuickTimeEventManager::OnInputPressed);
+                    PC->onAnyKeyReleased.AddDynamic(this, &UQuickTimeEventManager::OnInputReleased);
                 });
         }
         UCommonFunctions::EnterSlowMotion();
@@ -168,12 +169,12 @@ void UQuickTimeEventManager::OnFirstEventInit()
 void UQuickTimeEventManager::CreateEvent(FQuickTimeEventEnqueProperties& properties, bool sequence)
 {
     Event event{ properties.type, properties.key, properties.callback, sequence };
-    GetWorld()->GetTimerManager().SetTimer(event.timer, [id = event.GetId(), manager = this]()
+    GetWorld()->GetTimerManager().SetTimer(event.timer, [id = event.GetId(), this]()
         {
             EQuickTimeEventResult result = EQuickTimeEventResult::FailedTime;
             if(auto WM = AMainGameModeBase::GetWidgetsManager())
                 result = WM->RemoveQuickTimeEvent(id);
-            manager->OnEventEnd(id, result);
+            this->OnEventEnd(id, result);
         }, properties.duration, false);
     _events.Add(event.GetId(), event);
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/AutohideWidget.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "AutohideWidget.h"
 
 #include "Animation/WidgetAnimation.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/DialogueRowWidgetManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "DialogueRowWidgetManager.h"
 
 #include "Blueprint/WidgetTree.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/InteractableHintWidgetManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "InteractableHintWidgetManager.h"
 
 #include "Blueprint/WidgetTree.h"
@@ -23,10 +22,10 @@ void UInteractableHintWidgetManager::Append(const UInteractableModificator* modi
         return;
     }
 
-    if(hintsMap.Contains(modificator) || !modificator->GetMappingContext())
+    if(hintsMap.Contains(modificator) || !modificator->GetMappingContext().IsValid())
         return;
 
-    const auto& mappings = modificator->GetMappingContext()->GetMappings();
+    const auto& mappings = modificator->GetMappingContext().LoadSynchronous()->GetMappings();
 
     for(int32 i = hints->GetChildrenCount() - count - mappings.Num(); i < 0; ++i)
     {

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/JournalWidget.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "JournalWidget.h"
 
 #include "Blueprint/WidgetTree.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/MainMenu/MainMenuButtonWidget.cpp

@@ -1,5 +1,4 @@
 // Oleg Petruny proprietary.
 
-
 #include "MainMenuButtonWidget.h"
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/MainMenu/MainMenuWidget.cpp

@@ -1,11 +1,10 @@
 // Oleg Petruny proprietary.
 
-
 #include "MainMenuWidget.h"
 
 #include "Animation/WidgetAnimation.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomGameInstance.h"
 #include "MainGameModeBase.h"
 #include "MainMenuButtonWidget.h"
 #include "Widgets/WidgetsManager.h"
@@ -14,13 +13,11 @@ bool UMainMenuWidget::Initialize()
 {
     if(ButtonLoadLastSave)
     {
-        if(auto GI = UCustomGameInstanceBase::GetGameInstance())
+        auto GI = UCustomGameInstance::GetGameInstance();
+        if(GI && GI->saveData)
         {
-            if(GI->saveData)
-            {
-                ButtonLoadLastSave->SetIsEnabled(true);
-                ButtonLoadLastSave->SetRenderOpacity(1.0f);
-            }
+            ButtonLoadLastSave->SetIsEnabled(true);
+            ButtonLoadLastSave->SetRenderOpacity(1.0f);
         }
     }
 

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/QuickTimeEventWidget.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "QuickTimeEventWidget.h"
 
 #include "Animation/WidgetAnimation.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/QuickTimeEventWidgetManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "QuickTimeEventWidgetManager.h"
 
 #include "Animation/UMGSequencePlayer.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/ResolutionResponsiveUserWidget.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "ResolutionResponsiveUserWidget.h"
 
 #include "Components/PanelSlot.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/WidgetsManager.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "WidgetsManager.h"
 
 #include "Blueprint/UserWidget.h"
@@ -10,7 +9,7 @@
 #include "Kismet/GameplayStatics.h"
 #include "UObject/ScriptInterface.h"
 
-#include "CustomGameInstanceBase.h"
+#include "CustomGameInstance.h"
 #include "Interactable/Interactable.h"
 #include "Interactable/Modificators/InteractableModificator.h"
 #include "Interactable/Modificators/InventoryInteractableModificator.h"

UnrealProject/Lost_Edge/Source/Lost_Edge/Private/Widgets/WorldDilationResponsiveUserWidget.cpp

@@ -1,6 +1,5 @@
 // Oleg Petruny proprietary.
 
-
 #include "WorldDilationResponsiveUserWidget.h"
 
 #include "Animation/UMGSequencePlayer.h"