Migration

Plugins/InteractionSystem/InteractionSystem.uplugin

@@ -0,0 +1,24 @@
+{
+	"FileVersion": 3,
+	"Version": 1,
+	"VersionName": "0.1",
+	"FriendlyName": "InteractionSystem",
+	"Description": "Triggerable interaction system",
+	"Category": "Gameplay",
+	"CreatedBy": "Amasson",
+	"CreatedByURL": "",
+	"DocsURL": "",
+	"MarketplaceURL": "",
+	"SupportURL": "",
+	"CanContainContent": true,
+	"IsBetaVersion": true,
+	"IsExperimentalVersion": false,
+	"Installed": false,
+	"Modules": [
+		{
+			"Name": "InteractionSystem",
+			"Type": "Runtime",
+			"LoadingPhase": "Default"
+		}
+	]
+}

Plugins/InteractionSystem/Source/InteractionSystem/InteractionSystem.Build.cs

@@ -0,0 +1,53 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+
+public class InteractionSystem : ModuleRules
+{
+	public InteractionSystem(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+				// ... add public include paths required here ...
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				// ... add other private include paths required here ...
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				// ... add other public dependencies that you statically link with here ...
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"CoreUObject",
+				"Engine",
+				"Slate",
+				"SlateCore",
+				// ... add private dependencies that you statically link with here ...	
+			}
+			);
+		
+		
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+				// ... add any modules that your module loads dynamically here ...
+			}
+			);
+	}
+}

Plugins/InteractionSystem/Source/InteractionSystem/Private/Components/InteractionControllerComponent.cpp

@@ -0,0 +1,137 @@
+// Amasson
+
+
+#include "Components/InteractionControllerComponent.h"
+#include "GameFramework/PlayerController.h"
+
+
+UInteractionControllerComponent::UInteractionControllerComponent()
+{
+	PrimaryComponentTick.bCanEverTick = true;
+
+}
+
+void UInteractionControllerComponent::BeginPlay()
+{
+	Super::BeginPlay();
+
+	OwningPlayerController = Cast<APlayerController>(GetOwner());
+
+	if (!IsValid(OwningPlayerController))
+	{
+		UE_LOG(LogTemp, Error, TEXT("UInteractionControllerComponent is not owned by a valid APlayerController"));
+	}
+}
+
+void UInteractionControllerComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+{
+	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
+
+	UpdateHover();
+}
+
+void UInteractionControllerComponent::TriggerHoveredObject()
+{
+	if (IsValid(HoveredObject))
+	{
+		bHoveredObjectPressed = true;
+		APawn* TriggeringPawn = nullptr;
+		if (IsValid(OwningPlayerController))
+			TriggeringPawn = OwningPlayerController->GetPawn();
+
+		Super::ExecuteTrigger(HoveredObject, OwningPlayerController, TriggeringPawn, FName("PlayerInteraction"), this);
+	}
+}
+
+void UInteractionControllerComponent::ReleaseTriggerHoveredObject()
+{
+	bHoveredObjectPressed = false;
+	if (IsValid(HoveredObject))
+	{
+		APawn* TriggeringPawn = nullptr;
+		if (IsValid(OwningPlayerController))
+			TriggeringPawn = OwningPlayerController->GetPawn();
+
+		Super::ExecuteReleaseTrigger(HoveredObject, OwningPlayerController, TriggeringPawn, FName("PlayerInteraction"), this);
+	}
+}
+
+void UInteractionControllerComponent::Activate(bool bReset)
+{
+	Super::Activate(bReset);
+
+	if (bReset)
+		CursorHit = FHitResult();
+	SetComponentTickEnabled(true);
+}
+
+void UInteractionControllerComponent::Deactivate()
+{
+	Super::Deactivate();
+
+	if (IsValid(HoveredObject))
+		UnhoverObject_Unsafe();
+	SetComponentTickEnabled(false);
+}
+
+void UInteractionControllerComponent::UpdateHover()
+{
+	if (!IsValid(OwningPlayerController))
+		return;
+
+	OwningPlayerController->GetHitResultUnderCursor(CursorChannel, false, CursorHit);
+
+	UObject* NewHitObject = GetHoverableObjectFromCursorHit();
+
+	if (IsValid(HoveredObject))
+	{
+		bool bCurrentHoverIsStillValid = IWorldHoverable::Execute_CanBeHovered(HoveredObject, OwningPlayerController, CursorHit);
+
+		bool bShouldUnhover = (!bCurrentHoverIsStillValid) || (NewHitObject != HoveredObject);
+		if (bShouldUnhover)
+			UnhoverObject_Unsafe();
+	}
+
+	if (!HoveredObject && IsValid(NewHitObject))
+	{
+		HoverObject(NewHitObject);
+	}
+}
+
+UObject* UInteractionControllerComponent::GetHoverableObjectFromCursorHit()
+{
+	UPrimitiveComponent* HitComponent = CursorHit.GetComponent();
+	if (IsValid(HitComponent) && HitComponent->Implements<UWorldHoverable>())
+	{
+		if (IWorldHoverable::Execute_CanBeHovered(HitComponent, OwningPlayerController, CursorHit))
+			return HitComponent;
+	}
+	AActor* HitActor = CursorHit.GetActor();
+	if (IsValid(HitActor) && HitActor->Implements<UWorldHoverable>())
+	{
+		if (IWorldHoverable::Execute_CanBeHovered(HitActor, OwningPlayerController, CursorHit))
+			return HitActor;
+	}
+	return nullptr;
+}
+
+void UInteractionControllerComponent::UnhoverObject_Unsafe()
+{
+	if (bHoveredObjectPressed)
+		ReleaseTriggerHoveredObject();
+
+	IWorldHoverable::Execute_HoveredEnd(HoveredObject, OwningPlayerController);
+
+	OnHoverObjectEnd.Broadcast(this, HoveredObject);
+
+	HoveredObject = nullptr;
+}
+
+void UInteractionControllerComponent::HoverObject(UObject* NewHoverObject)
+{
+	HoveredObject = NewHoverObject;
+
+	IWorldHoverable::Execute_HoveredBegin(HoveredObject, OwningPlayerController, CursorHit);
+
+	OnHoverObjectBegin.Broadcast(this, HoveredObject);
+}

Plugins/InteractionSystem/Source/InteractionSystem/Private/Components/ObjectTriggererComponent.cpp

@@ -0,0 +1,119 @@
+// Amasson
+
+
+#include "Components/ObjectTriggererComponent.h"
+#include "Interfaces/Triggerable.h"
+#include "GameFramework/GameStateBase.h"
+
+UObjectTriggererComponent::UObjectTriggererComponent()
+{
+	PrimaryComponentTick.bCanEverTick = false;
+
+	SetIsReplicatedByDefault(true);
+}
+
+void UObjectTriggererComponent::BeginPlay()
+{
+	Super::BeginPlay();
+
+	GlobalObjectTriggerer = GetGlobalObjectTriggererComponent();
+}
+
+
+void UObjectTriggererComponent::ExecuteTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	if (IsValid(TriggerableObject) && TriggerableObject->Implements<UTriggerable>())
+	{
+		ETriggerMode TriggerMode = ITriggerable::Execute_GetTriggerMode(TriggerableObject);
+		switch (TriggerMode)
+		{
+		case ETriggerMode::TM_Server:
+			Server_ExecuteTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+			break;
+		case ETriggerMode::TM_Client:
+			Client_ExecuteTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+			break;
+		case ETriggerMode::TM_Multicast:
+			Server_MulticastExecuteTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+			break;
+		}
+	}
+}
+
+void UObjectTriggererComponent::ExecuteReleaseTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	if (IsValid(TriggerableObject) && TriggerableObject->Implements<UTriggerable>())
+	{
+		ETriggerMode TriggerMode = ITriggerable::Execute_GetTriggerMode(TriggerableObject);
+		switch (TriggerMode)
+		{
+		case ETriggerMode::TM_Server:
+			Server_ExecuteReleaseTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+			break;
+		case ETriggerMode::TM_Client:
+			Client_ExecuteReleaseTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+			break;
+		case ETriggerMode::TM_Multicast:
+			Server_MulticastExecuteReleaseTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+			break;
+		}
+	}
+}
+
+
+void UObjectTriggererComponent::Server_ExecuteTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	ITriggerable::Execute_Trigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+void UObjectTriggererComponent::Client_ExecuteTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	ITriggerable::Execute_Trigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+void UObjectTriggererComponent::Server_MulticastExecuteTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	UObjectTriggererComponent* Triggerer = GlobalObjectTriggerer;
+	if (!IsValid(Triggerer))
+		Triggerer = this;
+	Triggerer->NetMulticast_ExecuteTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+void UObjectTriggererComponent::NetMulticast_ExecuteTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	ITriggerable::Execute_Trigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+void UObjectTriggererComponent::Server_ExecuteReleaseTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	ITriggerable::Execute_ReleaseTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+void UObjectTriggererComponent::Client_ExecuteReleaseTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	ITriggerable::Execute_ReleaseTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+void UObjectTriggererComponent::Server_MulticastExecuteReleaseTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	UObjectTriggererComponent* Triggerer = GlobalObjectTriggerer;
+	if (!IsValid(Triggerer))
+		Triggerer = this;
+	Triggerer->NetMulticast_ExecuteReleaseTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+void UObjectTriggererComponent::NetMulticast_ExecuteReleaseTrigger_Implementation(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+	ITriggerable::Execute_ReleaseTrigger(TriggerableObject, TriggeringController, TriggeringPawn, Tag, Payload);
+}
+
+UObjectTriggererComponent* UObjectTriggererComponent::GetGlobalObjectTriggererComponent() const
+{
+	AGameStateBase* GameState = GetWorld()->GetGameState();
+	UObjectTriggererComponent *GlobalTrigger = GameState->GetComponentByClass<UObjectTriggererComponent>();
+
+	if (!IsValid(GlobalTrigger))
+		UE_LOG(LogTemp, Warning, TEXT("No UObjectTriggererComponent in GameState... Multicast triggers won't be executed by everyone"));
+
+	return GlobalTrigger;
+}

Plugins/InteractionSystem/Source/InteractionSystem/Private/Components/Shapes/BoxInteractionComponent.cpp

@@ -0,0 +1,58 @@
+// Amasson
+
+
+#include "Components/Shapes/BoxInteractionComponent.h"
+
+/** Trigger */
+
+void UBoxInteractionComponent::Trigger_Implementation(AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+    if (IsValid(TriggeringActor) && TriggeringActor->Implements<UTriggerable>())
+    {
+        ITriggerable::Execute_Trigger(TriggeringActor, TriggeringController, TriggeringPawn, this->TriggeringTag, this->TriggeringPayload);
+    }
+}
+
+void UBoxInteractionComponent::ReleaseTrigger_Implementation(AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload)
+{
+    if (IsValid(TriggeringActor) && TriggeringActor->Implements<UTriggerable>())
+    {
+        ITriggerable::Execute_ReleaseTrigger(TriggeringActor, TriggeringController, TriggeringPawn, this->TriggeringTag, this->TriggeringPayload);
+    }
+}
+
+ETriggerMode UBoxInteractionComponent::GetTriggerMode_Implementation() const
+{
+    if (IsValid(TriggeringActor) && TriggeringActor->Implements<UTriggerable>())
+    {
+        return ITriggerable::Execute_GetTriggerMode(TriggeringActor);
+    }
+    return ETriggerMode::TM_Client;
+}
+
+
+/** Hovering */
+
+void UBoxInteractionComponent::GetWorldHoverableInfos_Implementation(FWorldHoverableInfos& Infos)
+{
+    Infos.Location = GetComponentTransform().TransformPosition(InfoLocationOffset);
+    Infos.Text = InfoText;
+    Infos.bScreenSpace = false;
+}
+
+bool UBoxInteractionComponent::CanBeHovered_Implementation(AController* Controller, const FHitResult& TraceHit)
+{
+    if (MaxRange >= 0)
+        return TraceHit.Distance < MaxRange;
+    return true;
+}
+
+void UBoxInteractionComponent::HoveredBegin_Implementation(AController* Controller, const FHitResult& TraceHit)
+{
+    OnHoverBegin.Broadcast(this, TraceHit);
+}
+
+void UBoxInteractionComponent::HoveredEnd_Implementation(AController* Controller)
+{
+    OnHoverEnd.Broadcast(this);
+}

Plugins/InteractionSystem/Source/InteractionSystem/Private/InteractionSystem.cpp

@@ -0,0 +1,20 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "InteractionSystem.h"
+
+#define LOCTEXT_NAMESPACE "FInteractionSystemModule"
+
+void FInteractionSystemModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+}
+
+void FInteractionSystemModule::ShutdownModule()
+{
+	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
+	// we call this function before unloading the module.
+}
+
+#undef LOCTEXT_NAMESPACE
+	
+IMPLEMENT_MODULE(FInteractionSystemModule, InteractionSystem)

Plugins/InteractionSystem/Source/InteractionSystem/Private/InteractionSystemLibrary.cpp

@@ -0,0 +1,11 @@
+// Amasson
+
+
+#include "InteractionSystemLibrary.h"
+
+void UInteractionSystemLibrary::DefaultsActorWorldHoverableInfos(AActor* Actor, FText TooltipText, FWorldHoverableInfos& Infos)
+{
+    Infos.Location = IsValid(Actor) ? Actor->GetActorLocation() : FVector();
+    Infos.Text = TooltipText;
+    Infos.bScreenSpace = false;
+}

Plugins/InteractionSystem/Source/InteractionSystem/Private/Interfaces/Triggerable.cpp

@@ -0,0 +1,5 @@
+// Amasson
+
+
+#include "Interfaces/Triggerable.h"
+

Plugins/InteractionSystem/Source/InteractionSystem/Private/Interfaces/WorldHoverable.cpp

@@ -0,0 +1,5 @@
+// Amasson
+
+
+#include "Interfaces/WorldHoverable.h"
+

Plugins/InteractionSystem/Source/InteractionSystem/Public/Components/InteractionControllerComponent.h

@@ -0,0 +1,81 @@
+// Amasson
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/ObjectTriggererComponent.h"
+#include "Interfaces/WorldHoverable.h"
+#include "Interfaces/Triggerable.h"
+#include "InteractionControllerComponent.generated.h"
+
+class APlayerController;
+
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnHoverObjectChangedSignature, UInteractionControllerComponent*, InteractionComponent, UObject*, WorldHoverable);
+
+UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
+class INTERACTIONSYSTEM_API UInteractionControllerComponent : public UObjectTriggererComponent
+{
+	GENERATED_BODY()
+
+public:
+
+	UInteractionControllerComponent();
+
+	virtual void BeginPlay() override;
+
+	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
+
+	UPROPERTY(BlueprintAssignable, Category = "Hover")
+	FOnHoverObjectChangedSignature OnHoverObjectBegin;
+
+	UPROPERTY(BlueprintAssignable, Category = "Hover")
+	FOnHoverObjectChangedSignature OnHoverObjectEnd;
+
+	UFUNCTION(BlueprintCallable, Category = "Hover")
+	FORCEINLINE UObject* GetHoveredObject() const { return HoveredObject; }
+
+	UFUNCTION(BlueprintCallable, Category = "Hover")
+	FORCEINLINE AActor* GetHoveredActor() const { return IsValid(HoveredObject) ? Cast<AActor>(HoveredObject) : nullptr; }
+
+	UFUNCTION(BlueprintCallable, Category = "Hover")
+	FORCEINLINE UActorComponent* GetHoveredComponent() const { return IsValid(HoveredObject) ? Cast<UActorComponent>(HoveredObject) : nullptr; }
+
+	UFUNCTION(BlueprintCallable, Category = "Cursor")
+	const FHitResult& GetCursorHit() const { return CursorHit; }
+
+	UFUNCTION(BlueprintCallable, Category = "Trigger")
+	void TriggerHoveredObject();
+
+	UFUNCTION(BlueprintCallable, Category = "Trigger")
+	void ReleaseTriggerHoveredObject();
+
+	virtual void Activate(bool bReset = false) override;
+	virtual void Deactivate() override;
+
+protected:
+
+	void UpdateHover();
+
+	UObject* GetHoverableObjectFromCursorHit();
+	void UnhoverObject_Unsafe();
+	void HoverObject(UObject* NewHoverObject);
+
+	UPROPERTY()
+	TObjectPtr<APlayerController> OwningPlayerController;
+
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Cursor", meta = (AllowPrivateAccess = true))
+	TEnumAsByte<ECollisionChannel> CursorChannel;
+
+	UPROPERTY()
+	FHitResult CursorHit;
+
+	UPROPERTY()
+	TObjectPtr<UObject> HoveredObject;
+
+	// UPROPERTY(EditAnywhere, Category = "Cursor", meta = (AllowPrivateAccess = true))
+	// TObjectPtr<UInputAction> InteractionInput;
+
+	bool bHoveredObjectPressed = false;
+
+};

Plugins/InteractionSystem/Source/InteractionSystem/Public/Components/ObjectTriggererComponent.h

@@ -0,0 +1,59 @@
+// Amasson
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/ActorComponent.h"
+#include "ObjectTriggererComponent.generated.h"
+
+
+UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
+class INTERACTIONSYSTEM_API UObjectTriggererComponent : public UActorComponent
+{
+	GENERATED_BODY()
+
+public:	
+
+	UObjectTriggererComponent();
+
+	virtual void BeginPlay() override;
+
+	UFUNCTION(BlueprintCallable, Category = "Trigger")
+	void ExecuteTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(BlueprintCallable, Category = "Trigger")
+	void ExecuteReleaseTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+protected:
+
+	UFUNCTION(Server, Reliable)
+	void Server_ExecuteTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(Client, Reliable)
+	void Client_ExecuteTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(Server, Reliable)
+	void Server_MulticastExecuteTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(NetMulticast, Reliable)
+	void NetMulticast_ExecuteTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(Server, Reliable)
+	void Server_ExecuteReleaseTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(Client, Reliable)
+	void Client_ExecuteReleaseTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(Server, Reliable)
+	void Server_MulticastExecuteReleaseTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(NetMulticast, Reliable)
+	void NetMulticast_ExecuteReleaseTrigger(UObject* TriggerableObject, AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+
+	UObjectTriggererComponent* GetGlobalObjectTriggererComponent() const;
+
+	UPROPERTY()
+	TObjectPtr<UObjectTriggererComponent> GlobalObjectTriggerer;
+
+};

Plugins/InteractionSystem/Source/InteractionSystem/Public/Components/Shapes/BoxInteractionComponent.h

@@ -0,0 +1,71 @@
+// Amasson
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Components/BoxComponent.h"
+#include "Interfaces/WorldHoverable.h"
+#include "Interfaces/Triggerable.h"
+#include "BoxInteractionComponent.generated.h"
+
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnInteractionHoverBeginSignature, UBoxInteractionComponent*, BoxInteraction, FHitResult, CursorHit);
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnInteractionHoverEndSignature, UBoxInteractionComponent*, BoxInteraction);
+
+/**
+ * 
+ */
+
+UCLASS( Blueprintable, ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
+class INTERACTIONSYSTEM_API UBoxInteractionComponent : public UBoxComponent, public IWorldHoverable, public ITriggerable
+{
+	GENERATED_BODY()
+
+public:
+
+	UPROPERTY(BlueprintAssignable)
+	FOnInteractionHoverBeginSignature OnHoverBegin;
+
+	UPROPERTY(BlueprintAssignable)
+	FOnInteractionHoverEndSignature OnHoverEnd;
+
+	/** Trigger */
+
+	virtual void Trigger_Implementation(AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload) override;
+	virtual void ReleaseTrigger_Implementation(AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload) override;
+	virtual ETriggerMode GetTriggerMode_Implementation() const override;
+
+
+	/** Hovering */
+
+	virtual void GetWorldHoverableInfos_Implementation(FWorldHoverableInfos& Infos) override;
+	virtual bool CanBeHovered_Implementation(AController* Controller, const FHitResult& TraceHit) override;
+	virtual void HoveredBegin_Implementation(AController* Controller, const FHitResult& TraceHit) override;
+	virtual void HoveredEnd_Implementation(AController* Controller) override;
+
+
+	/** Trigger Properties */
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interaction")
+	TObjectPtr<AActor> TriggeringActor;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interaction")
+	FName TriggeringTag;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interaction")
+	TObjectPtr<UObject> TriggeringPayload;
+
+
+	/** Hovering Properties */
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interaction")
+	float MaxRange = -1;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interaction")
+	FVector InfoLocationOffset;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Interaction")
+	FText InfoText;
+	
+
+};

Plugins/InteractionSystem/Source/InteractionSystem/Public/InteractionSystem.h

@@ -0,0 +1,15 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+class FInteractionSystemModule : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+};

Plugins/InteractionSystem/Source/InteractionSystem/Public/InteractionSystemLibrary.h

@@ -0,0 +1,23 @@
+// Amasson
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Interfaces/WorldHoverable.h"
+#include "InteractionSystemLibrary.generated.h"
+
+/**
+ * 
+ */
+UCLASS()
+class INTERACTIONSYSTEM_API UInteractionSystemLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+
+public:
+
+	UFUNCTION(BlueprintCallable, BlueprintPure, Category = "WorldTooltip", meta = (DefaultToSelf = "Actor"))
+	static void DefaultsActorWorldHoverableInfos(AActor* Actor, FText TooltipText, FWorldHoverableInfos& Infos);
+
+};

Plugins/InteractionSystem/Source/InteractionSystem/Public/Interfaces/Triggerable.h

@@ -0,0 +1,45 @@
+// Amasson
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "Triggerable.generated.h"
+
+
+UENUM(BlueprintType)
+enum class ETriggerMode : uint8
+{
+	TM_Multicast	UMETA(DisplayName="Multicast"),
+	TM_Server		UMETA(DisplayName="Server"),
+	TM_Client		UMETA(DisplayName="Client"),
+};
+
+
+// This class does not need to be modified.
+UINTERFACE(MinimalAPI)
+class UTriggerable : public UInterface
+{
+	GENERATED_BODY()
+};
+
+/**
+ * 
+ */
+class INTERACTIONSYSTEM_API ITriggerable
+{
+	GENERATED_BODY()
+
+	// Add interface functions to this class. This is the class that will be inherited to implement this interface.
+public:
+
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Triggerable")
+	void Trigger(AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Triggerable")
+	void ReleaseTrigger(AController* TriggeringController, APawn* TriggeringPawn, FName Tag, UObject* Payload);
+
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "Triggerable")
+	ETriggerMode GetTriggerMode() const;
+
+};

Plugins/InteractionSystem/Source/InteractionSystem/Public/Interfaces/WorldHoverable.h

@@ -0,0 +1,59 @@
+// Amasson
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+#include "WorldHoverable.generated.h"
+
+
+USTRUCT(BlueprintType)
+struct INTERACTIONSYSTEM_API FWorldHoverableInfos
+{
+    GENERATED_BODY()
+
+public:
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	FVector Location = FVector::ZeroVector;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	FText Text;
+
+	/** Is Location in Screen Space or World Space */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite)
+	bool bScreenSpace = false;
+
+};
+
+
+// This class does not need to be modified.
+UINTERFACE(MinimalAPI)
+class UWorldHoverable : public UInterface
+{
+	GENERATED_BODY()
+};
+
+/**
+ * 
+ */
+class INTERACTIONSYSTEM_API IWorldHoverable
+{
+	GENERATED_BODY()
+
+	// Add interface functions to this class. This is the class that will be inherited to implement this interface.
+public:
+
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "WorldTooltip")
+	void GetWorldHoverableInfos(FWorldHoverableInfos& Infos);
+
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "WorldTooltip")
+	bool CanBeHovered(AController* Controller, const FHitResult& TraceHit);
+
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "WorldTooltip")
+	void HoveredBegin(AController* Controller, const FHitResult& TraceHit);
+
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = "WorldTooltip")
+	void HoveredEnd(AController* Controller);
+
+};