implementation

Unreal/PS_StratVision/Plugins/PS_StrategicVision/README.md

@@ -21,10 +21,10 @@ avec le projet).
 
 | Classe | Rôle |
 |---|---|
-| `UPSVisionConeComponent` | Component à poser sur un personnage : affiche son cône de vision (mesh procédural, bloqué par les murs). |
-| `UPSStrategicDisplayComponent` | Classe de base commune à tous les affichages stratégiques (camp, activation, couleur). Les futurs components en hériteront. |
-| `UPSStrategicVisionSubsystem` | Subsystem monde : interrupteurs globaux (tout, par catégorie, par camp). |
-| `UPSStrategicVisionSettings` | Réglages projet : couleurs des camps, matériau par défaut. |
+| `UPS_VisionConeComponent` | Component à poser sur un personnage : affiche son cône de vision (mesh procédural, bloqué par les murs). |
+| `UPS_StrategicDisplayComponent` | Classe de base commune à tous les affichages stratégiques (camp, activation, couleur). Les futurs components en hériteront. |
+| `UPS_StrategicVisionSubsystem` | Subsystem monde : interrupteurs globaux (tout, par catégorie, par camp). |
+| `UPS_StrategicVisionSettings` | Réglages projet : couleurs des camps, matériau par défaut. |
 
 ## Utilisation
 
@@ -50,14 +50,14 @@ Par component :
 
 - `SetDisplayEnabled(bool)` — interrupteur local du component.
 
-Globalement, via le subsystem (Blueprint : nœud `Get PSStrategicVisionSubsystem`,
-ou `UPSStrategicVisionSubsystem::Get(WorldContext)` en C++) :
+Globalement, via le subsystem (Blueprint : nœud `Get PS_StrategicVisionSubsystem`,
+ou `UPS_StrategicVisionSubsystem::Get(WorldContext)` en C++) :
 
 - `SetGlobalDisplayEnabled(bool)` — tout l'affichage stratégique (ex : entrée/sortie
   du mode spectateur ou replay).
 - `SetVisionConesEnabled(bool)` — uniquement les cônes de vision.
 - `SetCategoryEnabled(FName, bool)` — par catégorie (pour les futurs components).
-- `SetTeamEnabled(EPSStrategicTeam, bool)` — par camp (ex : ne montrer que les ennemis).
+- `SetTeamEnabled(EPS_StrategicTeam, bool)` — par camp (ex : ne montrer que les ennemis).
 
 Un component n'est visible que si son interrupteur local ET les interrupteurs
 globaux le permettent. Quand un cône est masqué, il ne fait plus aucune trace
@@ -98,4 +98,4 @@ déjà double face).
 
 - [x] Cône de vision bloqué par les obstacles
 - [ ] Autres affichages stratégiques (trajectoires, zones d'alerte, ...) sous forme
-  de components héritant de `UPSStrategicDisplayComponent`
+  de components héritant de `UPS_StrategicDisplayComponent`

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PSStrategicDisplayComponent.cpp

@@ -1,97 +0,0 @@
-// Copyright (c) 2026 j.foucher. All rights reserved.
-
-#include "PSStrategicDisplayComponent.h"
-
-#include "Engine/World.h"
-#include "PSStrategicVisionSettings.h"
-#include "PSStrategicVisionSubsystem.h"
-
-UPSStrategicDisplayComponent::UPSStrategicDisplayComponent()
-{
-	PrimaryComponentTick.bCanEverTick = false;
-}
-
-void UPSStrategicDisplayComponent::SetTeam(EPSStrategicTeam NewTeam)
-{
-	if (Team != NewTeam)
-	{
-		Team = NewTeam;
-		RefreshDisplayState();
-	}
-}
-
-void UPSStrategicDisplayComponent::SetDisplayEnabled(bool bEnabled)
-{
-	if (bDisplayEnabled != bEnabled)
-	{
-		bDisplayEnabled = bEnabled;
-		RefreshDisplayState();
-	}
-}
-
-bool UPSStrategicDisplayComponent::IsDisplayVisible() const
-{
-	if (!bDisplayEnabled)
-	{
-		return false;
-	}
-
-	if (const UWorld* World = GetWorld())
-	{
-		if (World->IsGameWorld())
-		{
-			if (const UPSStrategicVisionSubsystem* Subsystem = World->GetSubsystem<UPSStrategicVisionSubsystem>())
-			{
-				return Subsystem->ShouldDisplay(GetDisplayCategory(), Team);
-			}
-		}
-	}
-
-	// Monde editeur (preview) : on suit uniquement l'activation locale.
-	return true;
-}
-
-FLinearColor UPSStrategicDisplayComponent::GetTeamColor() const
-{
-	return GetDefault<UPSStrategicVisionSettings>()->GetTeamColor(Team);
-}
-
-void UPSStrategicDisplayComponent::BeginPlay()
-{
-	Super::BeginPlay();
-
-	if (UPSStrategicVisionSubsystem* Subsystem = UPSStrategicVisionSubsystem::Get(this))
-	{
-		Subsystem->OnDisplayStateChanged.AddUniqueDynamic(this, &UPSStrategicDisplayComponent::HandleGlobalDisplayStateChanged);
-	}
-
-	RefreshDisplayState();
-}
-
-void UPSStrategicDisplayComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
-{
-	if (UPSStrategicVisionSubsystem* Subsystem = UPSStrategicVisionSubsystem::Get(this))
-	{
-		Subsystem->OnDisplayStateChanged.RemoveDynamic(this, &UPSStrategicDisplayComponent::HandleGlobalDisplayStateChanged);
-	}
-
-	Super::EndPlay(EndPlayReason);
-}
-
-#if WITH_EDITOR
-void UPSStrategicDisplayComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
-{
-	Super::PostEditChangeProperty(PropertyChangedEvent);
-	RefreshDisplayState();
-}
-#endif
-
-void UPSStrategicDisplayComponent::RefreshDisplayState()
-{
-	OnDisplayStateChanged();
-}
-
-void UPSStrategicDisplayComponent::HandleGlobalDisplayStateChanged()
-{
-	RefreshDisplayState();
-}

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PSStrategicVisionSettings.cpp

@@ -1,26 +0,0 @@
-// Copyright (c) 2026 j.foucher. All rights reserved.
-
-#include "PSStrategicVisionSettings.h"
-
-#include "Materials/MaterialInterface.h"
-
-UPSStrategicVisionSettings::UPSStrategicVisionSettings()
-{
-	TeamColors.Add(EPSStrategicTeam::Player, FLinearColor(0.05f, 0.45f, 1.0f));
-	TeamColors.Add(EPSStrategicTeam::Ally, FLinearColor(0.1f, 0.9f, 0.5f));
-	TeamColors.Add(EPSStrategicTeam::Enemy, FLinearColor(1.0f, 0.12f, 0.08f));
-	TeamColors.Add(EPSStrategicTeam::Neutral, FLinearColor(0.75f, 0.75f, 0.75f));
-
-	// Materiau optionnel a creer dans le Content du plugin (voir README).
-	DefaultConeMaterial = TSoftObjectPtr<UMaterialInterface>(
-		FSoftObjectPath(TEXT("/PS_StrategicVision/Materials/M_VisionCone.M_VisionCone")));
-}
-
-FLinearColor UPSStrategicVisionSettings::GetTeamColor(EPSStrategicTeam Team) const
-{
-	if (const FLinearColor* Color = TeamColors.Find(Team))
-	{
-		return *Color;
-	}
-	return FLinearColor::White;
-}

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PSStrategicVisionTypes.cpp

@@ -1,5 +0,0 @@
-// Copyright (c) 2026 j.foucher. All rights reserved.
-
-#include "PSStrategicVisionTypes.h"
-
-const FName FPSStrategicDisplayCategories::VisionCone(TEXT("VisionCone"));

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PS_StrategicDisplayComponent.cpp

@@ -0,0 +1,97 @@
+// Copyright (c) 2026 j.foucher. All rights reserved.
+
+#include "PS_StrategicDisplayComponent.h"
+
+#include "Engine/World.h"
+#include "PS_StrategicVisionSettings.h"
+#include "PS_StrategicVisionSubsystem.h"
+
+UPS_StrategicDisplayComponent::UPS_StrategicDisplayComponent()
+{
+	PrimaryComponentTick.bCanEverTick = false;
+}
+
+void UPS_StrategicDisplayComponent::SetTeam(EPS_StrategicTeam NewTeam)
+{
+	if (Team != NewTeam)
+	{
+		Team = NewTeam;
+		RefreshDisplayState();
+	}
+}
+
+void UPS_StrategicDisplayComponent::SetDisplayEnabled(bool bEnabled)
+{
+	if (bDisplayEnabled != bEnabled)
+	{
+		bDisplayEnabled = bEnabled;
+		RefreshDisplayState();
+	}
+}
+
+bool UPS_StrategicDisplayComponent::IsDisplayVisible() const
+{
+	if (!bDisplayEnabled)
+	{
+		return false;
+	}
+
+	if (const UWorld* World = GetWorld())
+	{
+		if (World->IsGameWorld())
+		{
+			if (const UPS_StrategicVisionSubsystem* Subsystem = World->GetSubsystem<UPS_StrategicVisionSubsystem>())
+			{
+				return Subsystem->ShouldDisplay(GetDisplayCategory(), Team);
+			}
+		}
+	}
+
+	// Monde editeur (preview) : on suit uniquement l'activation locale.
+	return true;
+}
+
+FLinearColor UPS_StrategicDisplayComponent::GetTeamColor() const
+{
+	return GetDefault<UPS_StrategicVisionSettings>()->GetTeamColor(Team);
+}
+
+void UPS_StrategicDisplayComponent::BeginPlay()
+{
+	Super::BeginPlay();
+
+	if (UPS_StrategicVisionSubsystem* Subsystem = UPS_StrategicVisionSubsystem::Get(this))
+	{
+		Subsystem->OnDisplayStateChanged.AddUniqueDynamic(this, &UPS_StrategicDisplayComponent::HandleGlobalDisplayStateChanged);
+	}
+
+	RefreshDisplayState();
+}
+
+void UPS_StrategicDisplayComponent::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+	if (UPS_StrategicVisionSubsystem* Subsystem = UPS_StrategicVisionSubsystem::Get(this))
+	{
+		Subsystem->OnDisplayStateChanged.RemoveDynamic(this, &UPS_StrategicDisplayComponent::HandleGlobalDisplayStateChanged);
+	}
+
+	Super::EndPlay(EndPlayReason);
+}
+
+#if WITH_EDITOR
+void UPS_StrategicDisplayComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
+{
+	Super::PostEditChangeProperty(PropertyChangedEvent);
+	RefreshDisplayState();
+}
+#endif
+
+void UPS_StrategicDisplayComponent::RefreshDisplayState()
+{
+	OnDisplayStateChanged();
+}
+
+void UPS_StrategicDisplayComponent::HandleGlobalDisplayStateChanged()
+{
+	RefreshDisplayState();
+}

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PS_StrategicVisionSettings.cpp

@@ -0,0 +1,26 @@
+// Copyright (c) 2026 j.foucher. All rights reserved.
+
+#include "PS_StrategicVisionSettings.h"
+
+#include "Materials/MaterialInterface.h"
+
+UPS_StrategicVisionSettings::UPS_StrategicVisionSettings()
+{
+	TeamColors.Add(EPS_StrategicTeam::Player, FLinearColor(0.05f, 0.45f, 1.0f));
+	TeamColors.Add(EPS_StrategicTeam::Ally, FLinearColor(0.1f, 0.9f, 0.5f));
+	TeamColors.Add(EPS_StrategicTeam::Enemy, FLinearColor(1.0f, 0.12f, 0.08f));
+	TeamColors.Add(EPS_StrategicTeam::Neutral, FLinearColor(0.75f, 0.75f, 0.75f));
+
+	// Materiau optionnel a creer dans le Content du plugin (voir README).
+	DefaultConeMaterial = TSoftObjectPtr<UMaterialInterface>(
+		FSoftObjectPath(TEXT("/PS_StrategicVision/Materials/M_VisionCone.M_VisionCone")));
+}
+
+FLinearColor UPS_StrategicVisionSettings::GetTeamColor(EPS_StrategicTeam Team) const
+{
+	if (const FLinearColor* Color = TeamColors.Find(Team))
+	{
+		return *Color;
+	}
+	return FLinearColor::White;
+}

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PS_StrategicVisionSubsystem.cpp

@@ -1,23 +1,23 @@
 // Copyright (c) 2026 j.foucher. All rights reserved.
 
-#include "PSStrategicVisionSubsystem.h"
+#include "PS_StrategicVisionSubsystem.h"
 
 #include "Engine/Engine.h"
 #include "Engine/World.h"
 
-UPSStrategicVisionSubsystem* UPSStrategicVisionSubsystem::Get(const UObject* WorldContextObject)
+UPS_StrategicVisionSubsystem* UPS_StrategicVisionSubsystem::Get(const UObject* WorldContextObject)
 {
 	if (GEngine)
 	{
 		if (const UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::ReturnNull))
 		{
-			return World->GetSubsystem<UPSStrategicVisionSubsystem>();
+			return World->GetSubsystem<UPS_StrategicVisionSubsystem>();
 		}
 	}
 	return nullptr;
 }
 
-void UPSStrategicVisionSubsystem::SetGlobalDisplayEnabled(bool bEnabled)
+void UPS_StrategicVisionSubsystem::SetGlobalDisplayEnabled(bool bEnabled)
 {
 	if (bGlobalEnabled != bEnabled)
 	{
@@ -26,7 +26,7 @@ void UPSStrategicVisionSubsystem::SetGlobalDisplayEnabled(bool bEnabled)
 	}
 }
 
-void UPSStrategicVisionSubsystem::SetCategoryEnabled(FName Category, bool bEnabled)
+void UPS_StrategicVisionSubsystem::SetCategoryEnabled(FName Category, bool bEnabled)
 {
 	const bool bChanged = bEnabled ? (DisabledCategories.Remove(Category) > 0) : !DisabledCategories.Contains(Category);
 	if (!bEnabled)
@@ -39,7 +39,7 @@ void UPSStrategicVisionSubsystem::SetCategoryEnabled(FName Category, bool bEnabl
 	}
 }
 
-void UPSStrategicVisionSubsystem::SetTeamEnabled(EPSStrategicTeam Team, bool bEnabled)
+void UPS_StrategicVisionSubsystem::SetTeamEnabled(EPS_StrategicTeam Team, bool bEnabled)
 {
 	const bool bChanged = bEnabled ? (DisabledTeams.Remove(Team) > 0) : !DisabledTeams.Contains(Team);
 	if (!bEnabled)
@@ -52,7 +52,7 @@ void UPSStrategicVisionSubsystem::SetTeamEnabled(EPSStrategicTeam Team, bool bEn
 	}
 }
 
-void UPSStrategicVisionSubsystem::NotifyStateChanged()
+void UPS_StrategicVisionSubsystem::NotifyStateChanged()
 {
 	OnDisplayStateChanged.Broadcast();
 }

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PS_StrategicVisionTypes.cpp

@@ -0,0 +1,5 @@
+// Copyright (c) 2026 j.foucher. All rights reserved.
+
+#include "PS_StrategicVisionTypes.h"
+
+const FName FPS_StrategicDisplayCategories::VisionCone(TEXT("VisionCone"));

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Private/PS_VisionConeComponent.cpp

@@ -1,6 +1,6 @@
 // Copyright (c) 2026 j.foucher. All rights reserved.
 
-#include "PSVisionConeComponent.h"
+#include "PS_VisionConeComponent.h"
 
 #include "CollisionQueryParams.h"
 #include "Engine/HitResult.h"
@@ -10,7 +10,7 @@
 #include "Materials/MaterialInstanceDynamic.h"
 #include "Materials/MaterialInterface.h"
 #include "ProceduralMeshComponent.h"
-#include "PSStrategicVisionSettings.h"
+#include "PS_StrategicVisionSettings.h"
 
 namespace
 {
@@ -22,7 +22,7 @@ namespace
 	const FName GOpacityParamName(TEXT("Opacity"));
 }
 
-UPSVisionConeComponent::UPSVisionConeComponent()
+UPS_VisionConeComponent::UPS_VisionConeComponent()
 {
 	PrimaryComponentTick.bCanEverTick = true;
 	PrimaryComponentTick.bStartWithTickEnabled = true;
@@ -31,7 +31,7 @@ UPSVisionConeComponent::UPSVisionConeComponent()
 	bTickInEditor = true;
 }
 
-void UPSVisionConeComponent::OnRegister()
+void UPS_VisionConeComponent::OnRegister()
 {
 	Super::OnRegister();
 
@@ -40,7 +40,7 @@ void UPSVisionConeComponent::OnRegister()
 	ApplyTeamColor();
 }
 
-void UPSVisionConeComponent::OnComponentDestroyed(bool bDestroyingHierarchy)
+void UPS_VisionConeComponent::OnComponentDestroyed(bool bDestroyingHierarchy)
 {
 	if (ConeMesh)
 	{
@@ -51,13 +51,13 @@ void UPSVisionConeComponent::OnComponentDestroyed(bool bDestroyingHierarchy)
 	Super::OnComponentDestroyed(bDestroyingHierarchy);
 }
 
-void UPSVisionConeComponent::BeginPlay()
+void UPS_VisionConeComponent::BeginPlay()
 {
 	Super::BeginPlay();
 	SetComponentTickInterval(UpdateInterval);
 }
 
-void UPSVisionConeComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
+void UPS_VisionConeComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
 {
 	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
 
@@ -67,7 +67,7 @@ void UPSVisionConeComponent::TickComponent(float DeltaTime, ELevelTick TickType,
 	}
 }
 
-void UPSVisionConeComponent::OnDisplayStateChanged()
+void UPS_VisionConeComponent::OnDisplayStateChanged()
 {
 	const bool bShouldDisplay = IsDisplayVisible();
 
@@ -88,7 +88,7 @@ void UPSVisionConeComponent::OnDisplayStateChanged()
 	}
 }
 
-void UPSVisionConeComponent::EnsureConeMesh()
+void UPS_VisionConeComponent::EnsureConeMesh()
 {
 	if (ConeMesh || !GetWorld())
 	{
@@ -109,7 +109,7 @@ void UPSVisionConeComponent::EnsureConeMesh()
 	ConeMesh->SetWorldRotation(FQuat::Identity);
 }
 
-void UPSVisionConeComponent::EnsureMaterial()
+void UPS_VisionConeComponent::EnsureMaterial()
 {
 	if (!ConeMesh)
 	{
@@ -120,7 +120,7 @@ void UPSVisionConeComponent::EnsureMaterial()
 
 	if (!BaseMaterial)
 	{
-		BaseMaterial = GetDefault<UPSStrategicVisionSettings>()->DefaultConeMaterial.LoadSynchronous();
+		BaseMaterial = GetDefault<UPS_StrategicVisionSettings>()->DefaultConeMaterial.LoadSynchronous();
 	}
 	if (!BaseMaterial)
 	{
@@ -142,7 +142,7 @@ void UPSVisionConeComponent::EnsureMaterial()
 	ConeMesh->SetMaterial(0, ConeMID);
 }
 
-void UPSVisionConeComponent::ApplyTeamColor()
+void UPS_VisionConeComponent::ApplyTeamColor()
 {
 	if (!ConeMID)
 	{
@@ -155,7 +155,7 @@ void UPSVisionConeComponent::ApplyTeamColor()
 	ConeMID->SetScalarParameterValue(GOpacityParamName, Opacity);
 }
 
-void UPSVisionConeComponent::RebuildCone()
+void UPS_VisionConeComponent::RebuildCone()
 {
 	UWorld* World = GetWorld();
 	if (!World || !ConeMesh)
@@ -171,7 +171,7 @@ void UPSVisionConeComponent::RebuildCone()
 		: GetForwardVector();
 	const FVector Up = bFlattenOnGround ? FVector::UpVector : GetUpVector();
 
-	FCollisionQueryParams QueryParams(TEXT("PSVisionCone"), bTraceComplex);
+	FCollisionQueryParams QueryParams(TEXT("PS_VisionCone"), bTraceComplex);
 	if (const AActor* Owner = GetOwner())
 	{
 		QueryParams.AddIgnoredActor(Owner);

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Public/PS_StrategicDisplayComponent.h

@@ -4,30 +4,30 @@
 
 #include "CoreMinimal.h"
 #include "Components/SceneComponent.h"
-#include "PSStrategicVisionTypes.h"
-#include "PSStrategicDisplayComponent.generated.h"
+#include "PS_StrategicVisionTypes.h"
+#include "PS_StrategicDisplayComponent.generated.h"
 
 /**
  * Classe de base des affichages strategiques poses sur les personnages
  * (cone de vision, et autres visualisations a venir).
  *
  * Gere le camp (couleur), l'activation locale du component et la
- * synchronisation avec l'etat global du UPSStrategicVisionSubsystem.
+ * synchronisation avec l'etat global du UPS_StrategicVisionSubsystem.
  */
-UCLASS(Abstract, ClassGroup = (PSStrategicVision), HideCategories = (Physics, Collision, Mobility))
-class PS_STRATEGICVISION_API UPSStrategicDisplayComponent : public USceneComponent
+UCLASS(Abstract, ClassGroup = (PS_StrategicVision), HideCategories = (Physics, Collision, Mobility))
+class PS_STRATEGICVISION_API UPS_StrategicDisplayComponent : public USceneComponent
 {
 	GENERATED_BODY()
 
 public:
-	UPSStrategicDisplayComponent();
+	UPS_StrategicDisplayComponent();
 
 	/** Change le camp (met a jour la couleur de l'affichage). */
 	UFUNCTION(BlueprintCallable, Category = "Strategic Display")
-	void SetTeam(EPSStrategicTeam NewTeam);
+	void SetTeam(EPS_StrategicTeam NewTeam);
 
 	UFUNCTION(BlueprintPure, Category = "Strategic Display")
-	EPSStrategicTeam GetTeam() const { return Team; }
+	EPS_StrategicTeam GetTeam() const { return Team; }
 
 	/** Active / desactive cet affichage precis (independamment de l'etat global). */
 	UFUNCTION(BlueprintCallable, Category = "Strategic Display")
@@ -44,7 +44,7 @@ public:
 	UFUNCTION(BlueprintPure, Category = "Strategic Display")
 	FLinearColor GetTeamColor() const;
 
-	/** Categorie declaree par chaque type d'affichage (cf. FPSStrategicDisplayCategories). */
+	/** Categorie declaree par chaque type d'affichage (cf. FPS_StrategicDisplayCategories). */
 	virtual FName GetDisplayCategory() const { return NAME_None; }
 
 protected:
@@ -63,7 +63,7 @@ protected:
 
 	/** Camp du personnage porteur, determine la couleur de l'affichage. */
 	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Strategic Display")
-	EPSStrategicTeam Team = EPSStrategicTeam::Enemy;
+	EPS_StrategicTeam Team = EPS_StrategicTeam::Enemy;
 
 	/** Etat d'activation local de cet affichage. */
 	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Strategic Display")

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Public/PS_StrategicVisionSettings.h

@@ -4,8 +4,8 @@
 
 #include "CoreMinimal.h"
 #include "Engine/DeveloperSettings.h"
-#include "PSStrategicVisionTypes.h"
-#include "PSStrategicVisionSettings.generated.h"
+#include "PS_StrategicVisionTypes.h"
+#include "PS_StrategicVisionSettings.generated.h"
 
 class UMaterialInterface;
 
@@ -14,18 +14,18 @@ class UMaterialInterface;
  * Accessibles dans Project Settings > Plugins > PS Strategic Vision.
  */
 UCLASS(Config = Game, DefaultConfig, meta = (DisplayName = "PS Strategic Vision"))
-class PS_STRATEGICVISION_API UPSStrategicVisionSettings : public UDeveloperSettings
+class PS_STRATEGICVISION_API UPS_StrategicVisionSettings : public UDeveloperSettings
 {
 	GENERATED_BODY()
 
 public:
-	UPSStrategicVisionSettings();
+	UPS_StrategicVisionSettings();
 
 	virtual FName GetCategoryName() const override { return TEXT("Plugins"); }
 
 	/** Couleur associee a chaque camp. */
 	UPROPERTY(EditAnywhere, Config, BlueprintReadOnly, Category = "Teams")
-	TMap<EPSStrategicTeam, FLinearColor> TeamColors;
+	TMap<EPS_StrategicTeam, FLinearColor> TeamColors;
 
 	/**
 	 * Materiau par defaut des cones de vision. La couleur est appliquee via le
@@ -38,5 +38,5 @@ public:
 
 	/** Couleur du camp demande (blanc si non configuree). */
 	UFUNCTION(BlueprintPure, Category = "PS Strategic Vision")
-	FLinearColor GetTeamColor(EPSStrategicTeam Team) const;
+	FLinearColor GetTeamColor(EPS_StrategicTeam Team) const;
 };

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Public/PS_StrategicVisionSubsystem.h

@@ -4,26 +4,26 @@
 
 #include "CoreMinimal.h"
 #include "Subsystems/WorldSubsystem.h"
-#include "PSStrategicVisionTypes.h"
-#include "PSStrategicVisionSubsystem.generated.h"
+#include "PS_StrategicVisionTypes.h"
+#include "PS_StrategicVisionSubsystem.generated.h"
 
-DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPSStrategicDisplayStateChanged);
+DECLARE_DYNAMIC_MULTICAST_DELEGATE(FPS_StrategicDisplayStateChanged);
 
 /**
  * Subsystem monde pilotant l'affichage strategique global.
  * Permet d'activer / desactiver tous les affichages, une categorie (ex : cones
  * de vision) ou un camp entier selon l'etat de jeu (vue spectateur, replay...).
- * Tous les UPSStrategicDisplayComponent s'y abonnent automatiquement.
+ * Tous les UPS_StrategicDisplayComponent s'y abonnent automatiquement.
  */
 UCLASS()
-class PS_STRATEGICVISION_API UPSStrategicVisionSubsystem : public UWorldSubsystem
+class PS_STRATEGICVISION_API UPS_StrategicVisionSubsystem : public UWorldSubsystem
 {
 	GENERATED_BODY()
 
 public:
 	/** Raccourci d'acces au subsystem depuis n'importe quel contexte monde. */
 	UFUNCTION(BlueprintPure, Category = "PS Strategic Vision", meta = (WorldContext = "WorldContextObject"))
-	static UPSStrategicVisionSubsystem* Get(const UObject* WorldContextObject);
+	static UPS_StrategicVisionSubsystem* Get(const UObject* WorldContextObject);
 
 	/** Interrupteur general de tous les affichages strategiques. */
 	UFUNCTION(BlueprintCallable, Category = "PS Strategic Vision")
@@ -41,32 +41,32 @@ public:
 
 	/** Active / desactive les affichages d'un camp (ex : ne montrer que les ennemis). */
 	UFUNCTION(BlueprintCallable, Category = "PS Strategic Vision")
-	void SetTeamEnabled(EPSStrategicTeam Team, bool bEnabled);
+	void SetTeamEnabled(EPS_StrategicTeam Team, bool bEnabled);
 
 	UFUNCTION(BlueprintPure, Category = "PS Strategic Vision")
-	bool IsTeamEnabled(EPSStrategicTeam Team) const { return !DisabledTeams.Contains(Team); }
+	bool IsTeamEnabled(EPS_StrategicTeam Team) const { return !DisabledTeams.Contains(Team); }
 
 	/** Raccourci : active / desactive tous les cones de vision. */
 	UFUNCTION(BlueprintCallable, Category = "PS Strategic Vision|Vision Cone")
-	void SetVisionConesEnabled(bool bEnabled) { SetCategoryEnabled(FPSStrategicDisplayCategories::VisionCone, bEnabled); }
+	void SetVisionConesEnabled(bool bEnabled) { SetCategoryEnabled(FPS_StrategicDisplayCategories::VisionCone, bEnabled); }
 
 	UFUNCTION(BlueprintPure, Category = "PS Strategic Vision|Vision Cone")
-	bool AreVisionConesEnabled() const { return IsCategoryEnabled(FPSStrategicDisplayCategories::VisionCone); }
+	bool AreVisionConesEnabled() const { return IsCategoryEnabled(FPS_StrategicDisplayCategories::VisionCone); }
 
 	/** Etat combine utilise par les components pour savoir s'ils doivent s'afficher. */
-	bool ShouldDisplay(FName Category, EPSStrategicTeam Team) const
+	bool ShouldDisplay(FName Category, EPS_StrategicTeam Team) const
 	{
 		return bGlobalEnabled && IsCategoryEnabled(Category) && IsTeamEnabled(Team);
 	}
 
 	/** Notifie a chaque changement d'etat global (les components s'y abonnent). */
 	UPROPERTY(BlueprintAssignable, Category = "PS Strategic Vision")
-	FPSStrategicDisplayStateChanged OnDisplayStateChanged;
+	FPS_StrategicDisplayStateChanged OnDisplayStateChanged;
 
 private:
 	void NotifyStateChanged();
 
 	bool bGlobalEnabled = true;
 	TSet<FName> DisabledCategories;
-	TSet<EPSStrategicTeam> DisabledTeams;
+	TSet<EPS_StrategicTeam> DisabledTeams;
 };

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Public/PS_StrategicVisionTypes.h

@@ -3,11 +3,11 @@
 #pragma once
 
 #include "CoreMinimal.h"
-#include "PSStrategicVisionTypes.generated.h"
+#include "PS_StrategicVisionTypes.generated.h"
 
 /** Camp d'un personnage, utilise pour colorer / filtrer les affichages strategiques. */
 UENUM(BlueprintType)
-enum class EPSStrategicTeam : uint8
+enum class EPS_StrategicTeam : uint8
 {
 	Player,
 	Ally,
@@ -19,7 +19,7 @@ enum class EPSStrategicTeam : uint8
  * Categories d'affichage strategique. Chaque type de component declare sa categorie,
  * ce qui permet de l'activer / desactiver globalement via le subsystem.
  */
-struct PS_STRATEGICVISION_API FPSStrategicDisplayCategories
+struct PS_STRATEGICVISION_API FPS_StrategicDisplayCategories
 {
 	static const FName VisionCone;
 };

Unreal/PS_StratVision/Plugins/PS_StrategicVision/Source/PS_StrategicVision/Public/PS_VisionConeComponent.h

@@ -4,8 +4,8 @@
 
 #include "CoreMinimal.h"
 #include "Engine/EngineTypes.h"
-#include "PSStrategicDisplayComponent.h"
-#include "PSVisionConeComponent.generated.h"
+#include "PS_StrategicDisplayComponent.h"
+#include "PS_VisionConeComponent.generated.h"
 
 class UMaterialInstanceDynamic;
 class UMaterialInterface;
@@ -15,20 +15,20 @@ class UProceduralMeshComponent;
  * Affiche le cone de vision d'un personnage sous forme de mesh procedural.
  * Le cone est decoupe par les obstacles (murs) via des line traces, colore
  * selon le camp, et activable / desactivable localement ou globalement
- * (vue spectateur, replay) via le UPSStrategicVisionSubsystem.
+ * (vue spectateur, replay) via le UPS_StrategicVisionSubsystem.
  *
  * A attacher sur le personnage : le cone suit la position du component et
  * s'oriente selon son yaw (rotation horizontale).
  */
-UCLASS(ClassGroup = (PSStrategicVision), meta = (BlueprintSpawnableComponent, DisplayName = "PS Vision Cone"))
-class PS_STRATEGICVISION_API UPSVisionConeComponent : public UPSStrategicDisplayComponent
+UCLASS(ClassGroup = (PS_StrategicVision), meta = (BlueprintSpawnableComponent, DisplayName = "PS Vision Cone"))
+class PS_STRATEGICVISION_API UPS_VisionConeComponent : public UPS_StrategicDisplayComponent
 {
 	GENERATED_BODY()
 
 public:
-	UPSVisionConeComponent();
+	UPS_VisionConeComponent();
 
-	virtual FName GetDisplayCategory() const override { return FPSStrategicDisplayCategories::VisionCone; }
+	virtual FName GetDisplayCategory() const override { return FPS_StrategicDisplayCategories::VisionCone; }
 
 	/** Portee de vision, en cm. */
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Vision Cone", meta = (ClampMin = "10.0", Units = "cm"))