LifePlay-Revival/Docs/Migration/etat/ST/STC/STC-T3-IMPL.md

Fiche STC-T3 — Niveau N3 — Modèle prévu lp-impl | utilisé claude-opus-5-5 — Agent lp-impl — Skills lp-ue-compat, ue-cpp-build, lp-build, sk-protocol
# STC-T3-IMPL : C++ ULPUserSettings (GameUserSettings.ini) et style des sliders de Settings (2026-10-10)

Copie `D:\Game\LifePlay-master 5.8`, branche `ue5.8`, HEAD `20620f6`. SPEC : `STC-SPEC.md` § 0-2, 7 (lue en entier).
Non compilé (fiche : BUILD par lp-builder, éditeur ouvert). Aucun asset, config, Build.cs ni git touché.

## 1. Fichiers modifiés (chemins, lignes)
| Fichier | État | Lignes (`wc -l`) | Fins de ligne (`git ls-files --eol` / `-o --eol`) | MD5 |
|---|---|---|---|---|
| `D:\Game\LifePlay-master 5.8\Source\LifePlay\LPUserSettings.h` | neuf | 59 | `w/lf` (comme le modèle `LPModSettingsLibrary.h/.cpp`, `i/lf w/lf`) | `7d67c3f755930bcf1c0fd4c65aced897` |
| `D:\Game\LifePlay-master 5.8\Source\LifePlay\LPUserSettings.cpp` | neuf | 115 | `w/lf` | `ba74f9e3e6dbaa4a02579be89ea2e037` |
| `D:\Game\LifePlay-master 5.8\Source\LifePlay\LPSettingsSubsystem.cpp` | modifié, +52 / -0 (`git diff --stat`) | 835 → 887 | `i/crlf w/crlf` (inchangé, CRLF gardé par Edit) | `2fe96f77…` → `ede28e6d9aeff9a27f1adb988c03ae36` |

- `LPSettingsSubsystem.h` non modifié (MD5 `0f98c055…` = instantané). `LifePlay.Build.cs` non modifié : `Slate`, `SlateCore`,
  `UMG` déjà en privé (`LifePlay.Build.cs:38`), `CoreUObject`/`Engine` en public (`:17`) ; aucune dépendance manquante (estimé :
  toutes les API utilisées sont dans ces modules).
- Dossier `Source/LifePlay` : 18 fichiers CRLF, 35 LF (`git ls-files --eol -- Source/LifePlay`) ; les neufs suivent leur modèle (LF).
- Aucun caractère hors ASCII dans les deux fichiers neufs (Grep `[^\x00-\x7F]` : 0 résultat).
- Emplacements dans `LPSettingsSubsystem.cpp` (après modification) : include `Components/Slider.h` l. 19 ; `CollectSliders`
  l. 281-303 ; couleurs l. 346-351 ; collecte l. 355 et 360 ; boucle de style l. 403-420 (`SetWidgetStyle` l. 415,
  `SetSliderBarColor` l. 417, `SetSliderHandleColor` l. 418, Grep relu).

## 2. Écarts à la SPEC (obligatoire)
- E1 (style, § 2.3) : les couleurs sont portées par la **teinte des pinceaux** du style (`NormalBarImage` 0.06/0.06/0.06/0.95,
  `HoveredBarImage` 0.12/0.12/0.12/0.98, `NormalThumbImage` 0.2/0.45/0.9/1, `HoveredThumbImage` 0.3/0.55/1/1) et
  `SetSliderBarColor` / `SetSliderHandleColor` reçoivent **blanc** (multiplicateur neutre). Motif : `SSlider::OnPaint` dessine
  teinte du pinceau × couleur (`SSlider.cpp:125, 137`) ; mettre les couleurs dans les pinceaux garde un état survolé distinct
  (`GetBarImage`/`GetThumbImage`, `SSlider.cpp:483-513`). Les teintes de survol (0.12 et 0.3/0.55/1) ne sont pas dans la SPEC
  (reprises de `SpinBgHover` et `CheckedHover`). Base = style propre du slider (`GetWidgetStyle`), pas `FCoreStyle` comme les
  SpinBox : pinceaux, `BarThickness` (2 px par défaut) et taille de poignée (8×14) gardés. Seuls appels d'écriture : les trois
  permis par la SPEC ; aucun `SetValue`, ni `SetIsEnabled`/`SetRenderOpacity`.
- E2 (portée du style, § 2.3) : appliqué, comme écrit, à **tous** les `USlider` de `SettingsScrollBox` : donc aussi aux 5 lignes
  `LPColor*` (`LPColorGradeSubsystem.cpp:298-302`), aux sliders `LPVideo*` (`LPVideoQualitySubsystem.cpp:392`) et à tout slider
  Blueprint de la liste. Effet visible au-delà du slider caméra : à confirmer par l'orchestrateur (une restriction au nom
  `SliderCameraSpeed` serait un changement d'une ligne).
- E3 (propriété GI absente) : interprétation de « avertissement, rien d'autre ». `ApplyCameraSpeedAtStartup` : avertissement
  puis retour, **ini non écrit** dans les deux branches (la reprise du premier lancement sera retentée). `SetCameraSpeed` :
  avertissement pour GI, **ini quand même mis à jour** (l'ini fait foi, D4). GameInstance nul = même traitement.
- E4 : `SetCameraSpeed` écrit une ligne `Display` à chaque écriture de l'ini (`Camera : vitesse N enregistree dans
  GameUserSettings.ini`) ; non demandé, utile à V5 ; au plus une ligne par cran réellement changé.
- E5 : formule de la SPEC gardée telle quelle, sans garde NaN : `FMath::Clamp` = `Max(Min(X, Max), Min)`
  (`UnrealMathUtility.h:592-595`), donc NaN → 7 (estimé par lecture du code, non essayé).
- E6 : broche `V` gardée (nom de la SPEC) pour `ClampCameraSpeed` et `SetCameraSpeed`.
- Aucun autre écart : signatures, catégorie `LifePlay|Settings`, `UCLASS(config = GameUserSettings)`, valeurs par défaut (3, faux),
  `SaveConfig()` seulement si valeur changée ou `bCameraSpeedSet` faux, lecture/écriture GI par réflexion `FDoubleProperty`
  puis `FFloatProperty`.

## 3. Instantané (lot, manifeste)
- Lot `STC`, manifeste `D:\Game\LifePlay_Backup_5.5\STC\manifest.csv` (fait par l'orchestrateur, 2026-10-10T09:11:26) :
  `LPUserSettings.h` et `.cpp` `Existed=False` ; `LPSettingsSubsystem.cpp` MD5 `2FE96F776A0F3DFDA803F6E0EB1BC73B` et `.h`
  `0F98C05568AE789C5C0B78F6EC580503`, identiques aux fichiers avant modification (`md5sum`, relu avant la première écriture).
- Retour arrière (proposé, non fait) : `Tools\Restore.ps1 -Lot STC` (déplace les deux neufs, restaure le `.cpp`).

## 4. Ce qui n'a pas été fait
- Compilation (BUILD par lp-builder, éditeur fermé) ; aucun build 5.5 de contrôle (le lot vit dans la copie 5.8).
- Blueprints `MainMenu` (§ 3) et `GI` (§ 4), CHG, ini, `GameSettings.sav` : hors fiche.
- Aucun commit, aucun `git add`, aucune écriture dans `Docs/` de la copie 5.8, aucun script.

## 5. Points à confirmer en VAL
- BUILD 5.8 : code 0 ; `LPUserSettings.gen.cpp` produit par UHT ; `LPUserSettings.cpp` et `LPSettingsSubsystem.cpp` compilés ; 0 avertissement nouveau (règles V7 : ombrage, code inatteignable).
- Unity build : espace de noms `LPUserSettingsGi` (nommé, unique : Grep `LPUserSettings` sur Source, Plugins et addon 5.8 avant écriture = 0) sans C2374.
- Palette Blueprint : 4 nœuds sous `LifePlay|Settings` avec les broches de la table « Signatures » (Constats).
- V8 : journal `LogLifePlay` `Display` « Camera : vitesse N reprise de GI (GameSettings.sav : X), ecrite dans GameUserSettings.ini (premier lancement) » et section `[/Script/LifePlay.LPUserSettings]` avec `CameraSpeed=…` et `bCameraSpeedSet=True`.
- V8 (risque) : valeur de `CameraSpeed` dans `GameSettings.sav` avant migration ; si elle vaut 0.2 (cause (c)), la reprise donne 1, pas 3 (`Round(0.2)=0` puis borne 1) ; attendu SPEC V8 = 3.
- V6 : au relancement, ligne « Camera : vitesse 5 lue dans GameUserSettings.ini (ini 5.00), recopiee dans GI (avant X) » et `GI.CameraSpeed = 5`.
- V5 : une ligne « enregistree dans GameUserSettings.ini » par cran changé, aucune quand la valeur ne change pas ; fichier écrit sur disque (`SaveConfig` → `Flush`, `Obj.cpp:3942-3944`).
- V9 : seule la section `LPUserSettings` ajoutée dans `GameUserSettings.ini`.
- Style (E1, E2) : slider caméra lisible sur fond clair (barre 2 px, poignée 8×14 inchangées) ; aspect des sliders `LPColor*` / `LPVideo*` / Blueprint acceptable ; aucune valeur de slider modifiée à l'ouverture du menu.
- Cases et SpinBox : rendu inchangé (aucune ligne de leur traitement modifiée, diff relu).

## 6. Fichiers à commiter
Dépôt jeu `D:\Game\LifePlay-master 5.8`, branche `ue5.8` :
A Source/LifePlay/LPUserSettings.h
A Source/LifePlay/LPUserSettings.cpp
M Source/LifePlay/LPSettingsSubsystem.cpp

Tours : 56 / 60

## Constats
### Signatures telles qu'un Blueprint les verra (estimé : affichage par `FName::NameToDisplayString`, à confirmer en VAL)
Cible : `LPUser Settings Library` (classe `ULPUserSettingsLibrary`, statiques, aucune broche Target). Catégorie `LifePlay|Settings`.
| Nœud (titre) | C++ | Type | Broches d'entrée (nom interne → affiché) | Broches de sortie |
|---|---|---|---|---|
| Clamp Camera Speed | `static float ClampCameraSpeed(float V)` | `BlueprintPure` | `V` → « V » (Float simple précision) | `ReturnValue` → « Return Value » (Float) |
| Apply Camera Speed At Startup | `static void ApplyCameraSpeedAtStartup(UObject* GameInstance)` | `BlueprintCallable` | `execute` ; `GameInstance` → « Game Instance » (Object Reference) | `then` |
| Set Camera Speed | `static void SetCameraSpeed(UObject* GameInstance, float V)` | `BlueprintCallable` | `execute` ; `GameInstance` → « Game Instance » ; `V` → « V » (Float) | `then` |
| Get Camera Speed | `static float GetCameraSpeed()` | `BlueprintPure` | — | `ReturnValue` → « Return Value » (Float) |
Pas de `DefaultToSelf` : la broche `GameInstance` doit être reliée (`self` dans GI, `Get Game Instance` dans MainMenu).
Classe de configuration : `ULPUserSettings` (`UCLASS(config = GameUserSettings)`, `UPROPERTY(config) float CameraSpeed = 3.f`,
`UPROPERTY(config) bool bCameraSpeedSet = false`), non visible des Blueprints (pas de spécificateur Blueprint, conforme SPEC 2.1).

### Choix faits
- Accès à l'ini : `GetMutableDefault<ULPUserSettings>()` (objet par défaut chargé de l'ini à sa création), écriture
  `SaveConfig()` sans argument : fichier = nom de config de la classe (`Obj.cpp:3697`, `GetConfigFilename` `Obj.cpp:2332-2338`,
  `UClass::GetConfigName` `Class.cpp:7144-7149` : `GameUserSettings` est un nom de config connu), puis `Flush` sur disque
  (`Obj.cpp:3942-3944`).
- Réflexion GI : `FindPropertyByName("CameraSpeed")`, `CastField<FDoubleProperty>` puis `CastField<FFloatProperty>`
  (`UnrealType.h:2507, 2547` ; `CastField` const `Field.h:1133`) ; `Get/SetPropertyValue_InContainer` const (`UnrealType.h:1663, 1673`).
  Tout autre type ou absence : `Warning` « pas de propriete reelle CameraSpeed dans <classe>, GI non touche ».
- `ApplyCameraSpeedAtStartup` : une ligne `Display` par appel réussi (source ini avec valeur ini et valeur GI d'avant, ou reprise
  depuis GI avec valeur du sav) ; `SaveConfig` seulement dans la branche premier lancement.
- `SetCameraSpeed` : GI toujours écrit (valeur bornée) ; ini et `SaveConfig` seulement si `!bCameraSpeedSet || CameraSpeed != V`
  (comparaison exacte : entiers 1-7 exacts en float).
- `GetCameraSpeed` : `bCameraSpeedSet ? ClampCameraSpeed(CameraSpeed) : 3`.
- Helpers dans l'espace de noms nommé `LPUserSettingsGi` (piège unity C2374, `lp-build` § 8) ; `FName` en `static` local (comme `LPModSettingsLibrary.cpp:13`).
- Compatibilité 5.5 (estimé, non compilé) : API du slider présentes en 5.5 (`UE_5.5/.../Components/Slider.h:147, 150, 184, 191`) ;
  aucune garde de version nécessaire ; aucun correctif UE4 (`LPStringCompat`, `LPMeshCompat`, `LPNavigationHelpers`…) touché.

### API moteur 5.8 lues (établi)
- `UE_5.8/Engine/Source/Runtime/UMG/Public/Components/Slider.h:151` `GetWidgetStyle`, `:154` `SetWidgetStyle`, `:188`
  `SetSliderBarColor(FLinearColor)`, `:195` `SetSliderHandleColor(FLinearColor)` ; accès direct aux membres déprécié 5.1 (`:51, 61, 66`).
- `UMG/Private/Components/Slider.cpp:210-217, 284-305` : ces setters ne touchent pas `Value` ; `:30` style d'exécution par défaut =
  `FDefaultStyleCache::GetRuntime().GetSliderStyle()` (`SlateCore/Private/Styling/DefaultStyleCache.cpp:60` → `UMGCoreStyle.cpp:723-731` :
  barre `FSlateColorBrush` blanche, poignée `Common/Button` 8×14, épaisseur 2).
- `SlateCore/Public/Styling/SlateTypes.h:1339-1386` : `FSliderStyle` (`NormalBarImage`, `HoveredBarImage`, `DisabledBarImage`,
  `NormalThumbImage`, `HoveredThumbImage`, `DisabledThumbImage`, `BarThickness`).
- `Slate/Private/Widgets/Input/SSlider.cpp:119-138` (peinture : teinte × couleur × teinte du widget), `:483-513` (pinceau survolé).
- `CoreUObject/Public/UObject/Object.h:1283` `SaveConfig(uint64 RequiredPropertyFlags = CPF_Config, const TCHAR* Filename = nullptr, …)`.
- `Core/Public/GenericPlatform/GenericPlatformMath.h:332` `RoundToFloat(float)` ; `Core/Public/Math/UnrealMathUtility.h:592` `Clamp`.
Aucune API supposée par la SPEC absente en 5.8 (arrêt rubrique 7 non déclenché).

### Diff complet
`Source/LifePlay/LPSettingsSubsystem.cpp` (`git diff`, CR retirés à l'affichage) :
```diff
@@ -16,6 +16,7 @@
 #include "Components/OverlaySlot.h"
 #include "Components/ScrollBox.h"
 #include "Components/SizeBox.h"
+#include "Components/Slider.h"
 #include "Components/SpinBox.h"
 #include "Components/TextBlock.h"
 #include "Components/PanelWidget.h"
@@ -277,6 +278,30 @@ namespace LPSettingsUi
 		}
 	}
 
+	void CollectSliders(UWidget* Widget, TArray<USlider*>& Out)
+	{
+		if (!Widget)
+		{
+			return;
+		}
+		if (USlider* Slider = Cast<USlider>(Widget))
+		{
+			Out.Add(Slider);
+			return;
+		}
+		if (UUserWidget* User = Cast<UUserWidget>(Widget))
+		{
+			CollectSliders(User->GetRootWidget(), Out);
+		}
+		if (UPanelWidget* Panel = Cast<UPanelWidget>(Widget))
+		{
+			for (int32 Index = 0; Index < Panel->GetChildrenCount(); ++Index)
+			{
+				CollectSliders(Panel->GetChildAt(Index), Out);
+			}
+		}
+	}
+
 	void TintBrush(FSlateBrush& Brush, const FLinearColor& Tint)
 	{
 		Brush.TintColor = FSlateColor(Tint);
@@ -318,12 +343,21 @@ namespace LPSettingsUi
 		TintBrush(SpinStyle.ActiveFillBrush, FLinearColor(0.2f, 0.45f, 0.9f, 0.85f));
 		SpinStyle.ForegroundColor = FSlateColor(FLinearColor(1.f, 1.f, 1.f, 1.f));
 
+		// Lot STC : sliders (vitesse de camera, lignes LPColor* et LPVideo*). Barre sombre comme le fond des spinboxes,
+		// poignee bleue comme leur remplissage. Style et couleurs seulement : aucune valeur ecrite (pas de SetValue).
+		const FLinearColor SliderBar(0.06f, 0.06f, 0.06f, 0.95f);
+		const FLinearColor SliderBarHover(0.12f, 0.12f, 0.12f, 0.98f);
+		const FLinearColor SliderHandle(0.2f, 0.45f, 0.9f, 1.f);
+		const FLinearColor SliderHandleHover(0.3f, 0.55f, 1.f, 1.f);
+
 		TArray<UCheckBox*> Boxes;
 		TArray<USpinBox*> Spins;
+		TArray<USlider*> Sliders;
 		for (int32 Index = 0; Index < Scroll->GetChildrenCount(); ++Index)
 		{
 			CollectCheckBoxes(Scroll->GetChildAt(Index), Boxes);
 			CollectSpinBoxes(Scroll->GetChildAt(Index), Spins);
+			CollectSliders(Scroll->GetChildAt(Index), Sliders);
 		}
 
 		for (UCheckBox* Box : Boxes)
@@ -366,6 +400,24 @@ namespace LPSettingsUi
 			Spin->SetFont(Font);
 		}
 
+		for (USlider* Slider : Sliders)
+		{
+			if (!Slider)
+			{
+				continue;
+			}
+			// Style propre du slider (pinceaux et epaisseur gardes), seules les teintes changent.
+			FSliderStyle SliderStyle = Slider->GetWidgetStyle();
+			TintBrush(SliderStyle.NormalBarImage, SliderBar);
+			TintBrush(SliderStyle.HoveredBarImage, SliderBarHover);
+			TintBrush(SliderStyle.NormalThumbImage, SliderHandle);
+			TintBrush(SliderStyle.HoveredThumbImage, SliderHandleHover);
+			Slider->SetWidgetStyle(SliderStyle);
+			// SSlider::OnPaint multiplie la teinte du pinceau par ces couleurs : blanc = teintes ci-dessus telles quelles.
+			Slider->SetSliderBarColor(FLinearColor::White);
+			Slider->SetSliderHandleColor(FLinearColor::White);
+		}
+
 		if (UWidget* ShowFPS = [&]() -> UWidget*
 			{
 				for (int32 Index = 0; Index < Scroll->GetChildrenCount(); ++Index)
```

`Source/LifePlay/LPUserSettings.h` (fichier neuf, 59 lignes, contenu intégral) :
```cpp
// Lot STC - vitesse de camera adossee a GameUserSettings.ini (STC-SPEC, partie 2).
//
// La valeur de reference de la vitesse de camera est la section [/Script/LifePlay.LPUserSettings] de
// GameUserSettings.ini (PIE : Saved/Config/WindowsEditor/, jeu : Saved/Config/Windows/). GI.CameraSpeed n'en est
// qu'une recopie : ApplyCameraSpeedAtStartup la remplit au demarrage (apres GI.LoadSettings), SetCameraSpeed la met a
// jour quand le joueur bouge le slider du menu Settings. L'ini n'est ecrit que si la valeur change, ou une fois au
// premier lancement (bCameraSpeedSet faux) : la valeur de GI, issue de GameSettings.sav, est alors reprise et bornee.
// GameSettings.sav garde son champ CameraSpeed, recopie de GI par GI.SaveSettings.
// Valeurs permises : entiers de 1 a 7 (slider a pas de 1), 3 par defaut.

#pragma once

#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "UObject/Object.h"
#include "LPUserSettings.generated.h"

/** Reglages du joueur propres a LifePlay, enregistres dans GameUserSettings.ini (objet par defaut seulement). */
UCLASS(config = GameUserSettings)
class LIFEPLAY_API ULPUserSettings : public UObject
{
	GENERATED_BODY()

public:
	/** Vitesse de camera choisie dans le menu Settings (1 a 7). */
	UPROPERTY(config)
	float CameraSpeed = 3.f;

	/** Faux tant que l'entree n'a jamais ete ecrite (premier lancement : reprise de GI.CameraSpeed). */
	UPROPERTY(config)
	bool bCameraSpeedSet = false;
};

UCLASS()
class LIFEPLAY_API ULPUserSettingsLibrary : public UBlueprintFunctionLibrary
{
	GENERATED_BODY()

public:
	/** Arrondit a l'entier le plus proche et borne entre 1 et 7. */
	UFUNCTION(BlueprintPure, Category = "LifePlay|Settings")
	static float ClampCameraSpeed(float V);

	/**
	 * A appeler au demarrage, apres GI.LoadSettings : recopie dans GI.CameraSpeed la valeur de GameUserSettings.ini.
	 * Premier lancement (entree jamais ecrite) : reprend GI.CameraSpeed (lu dans GameSettings.sav), la borne, l'ecrit
	 * dans GI et dans l'ini.
	 */
	UFUNCTION(BlueprintCallable, Category = "LifePlay|Settings")
	static void ApplyCameraSpeedAtStartup(UObject* GameInstance);

	/** Slider du menu Settings : borne V, l'ecrit dans GI.CameraSpeed et, si elle change, dans GameUserSettings.ini. */
	UFUNCTION(BlueprintCallable, Category = "LifePlay|Settings")
	static void SetCameraSpeed(UObject* GameInstance, float V);

	/** Vitesse de camera enregistree dans GameUserSettings.ini, bornee (3 si jamais ecrite). */
	UFUNCTION(BlueprintPure, Category = "LifePlay|Settings")
	static float GetCameraSpeed();
};
```

`Source/LifePlay/LPUserSettings.cpp` (fichier neuf, 115 lignes, contenu intégral) :
```cpp
// Lot STC - voir LPUserSettings.h

#include "LPUserSettings.h"

#include "LifePlay.h"
#include "UObject/UnrealType.h"

namespace LPUserSettingsGi
{
	constexpr float DefaultCameraSpeed = 3.f;

	// GI.CameraSpeed est une variable Blueprint : reel double en 5.x (FDoubleProperty), float accepte aussi.
	// Propriete absente ou d'un autre type : avertissement, GI n'est pas touche.
	FProperty* FindCameraSpeed(UObject* GameInstance, const TCHAR* Caller)
	{
		static const FName CameraSpeedName(TEXT("CameraSpeed"));
		if (!GameInstance)
		{
			UE_LOG(LogLifePlay, Warning, TEXT("Camera : %s sans GameInstance, GI.CameraSpeed non touche"), Caller);
			return nullptr;
		}
		FProperty* Prop = GameInstance->GetClass()->FindPropertyByName(CameraSpeedName);
		if (!CastField<FDoubleProperty>(Prop) && !CastField<FFloatProperty>(Prop))
		{
			UE_LOG(LogLifePlay, Warning, TEXT("Camera : %s, pas de propriete reelle CameraSpeed dans %s, GI non touche"),
				Caller, *GameInstance->GetClass()->GetName());
			return nullptr;
		}
		return Prop;
	}

	float ReadValue(const FProperty* Prop, const UObject* GameInstance)
	{
		if (const FDoubleProperty* AsDouble = CastField<FDoubleProperty>(Prop))
		{
			return static_cast<float>(AsDouble->GetPropertyValue_InContainer(GameInstance));
		}
		if (const FFloatProperty* AsFloat = CastField<FFloatProperty>(Prop))
		{
			return AsFloat->GetPropertyValue_InContainer(GameInstance);
		}
		return DefaultCameraSpeed;
	}

	void WriteValue(const FProperty* Prop, UObject* GameInstance, float Value)
	{
		if (const FDoubleProperty* AsDouble = CastField<FDoubleProperty>(Prop))
		{
			AsDouble->SetPropertyValue_InContainer(GameInstance, static_cast<double>(Value));
		}
		else if (const FFloatProperty* AsFloat = CastField<FFloatProperty>(Prop))
		{
			AsFloat->SetPropertyValue_InContainer(GameInstance, Value);
		}
	}
}

float ULPUserSettingsLibrary::ClampCameraSpeed(float V)
{
	return FMath::Clamp(FMath::RoundToFloat(V), 1.f, 7.f);
}

void ULPUserSettingsLibrary::ApplyCameraSpeedAtStartup(UObject* GameInstance)
{
	ULPUserSettings* Settings = GetMutableDefault<ULPUserSettings>();
	FProperty* Prop = LPUserSettingsGi::FindCameraSpeed(GameInstance, TEXT("ApplyCameraSpeedAtStartup"));
	if (!Prop)
	{
		// Avertissement deja ecrit. Ini inchange : au premier lancement, la reprise depuis GI sera retentee.
		return;
	}
	if (Settings->bCameraSpeedSet)
	{
		const float Value = ClampCameraSpeed(Settings->CameraSpeed);
		const float Before = LPUserSettingsGi::ReadValue(Prop, GameInstance);
		LPUserSettingsGi::WriteValue(Prop, GameInstance, Value);
		UE_LOG(LogLifePlay, Display, TEXT("Camera : vitesse %.0f lue dans GameUserSettings.ini (ini %.2f), recopiee dans GI (avant %.2f)"),
			Value, Settings->CameraSpeed, Before);
		return;
	}
	// Premier lancement : entree jamais ecrite. GI.CameraSpeed vient de GameSettings.sav (GI.LoadSettings).
	const float FromGi = LPUserSettingsGi::ReadValue(Prop, GameInstance);
	const float Value = ClampCameraSpeed(FromGi);
	LPUserSettingsGi::WriteValue(Prop, GameInstance, Value);
	Settings->CameraSpeed = Value;
	Settings->bCameraSpeedSet = true;
	Settings->SaveConfig();
	UE_LOG(LogLifePlay, Display, TEXT("Camera : vitesse %.0f reprise de GI (GameSettings.sav : %.2f), ecrite dans GameUserSettings.ini (premier lancement)"),
		Value, FromGi);
}

void ULPUserSettingsLibrary::SetCameraSpeed(UObject* GameInstance, float V)
{
	const float Value = ClampCameraSpeed(V);
	if (FProperty* Prop = LPUserSettingsGi::FindCameraSpeed(GameInstance, TEXT("SetCameraSpeed")))
	{
		LPUserSettingsGi::WriteValue(Prop, GameInstance, Value);
	}
	// L'ini fait foi : ecrit seulement si la valeur change, ou si l'entree n'a jamais ete ecrite.
	ULPUserSettings* Settings = GetMutableDefault<ULPUserSettings>();
	if (Settings->bCameraSpeedSet && Settings->CameraSpeed == Value)
	{
		return;
	}
	Settings->CameraSpeed = Value;
	Settings->bCameraSpeedSet = true;
	Settings->SaveConfig();
	UE_LOG(LogLifePlay, Display, TEXT("Camera : vitesse %.0f enregistree dans GameUserSettings.ini"), Value);
}

float ULPUserSettingsLibrary::GetCameraSpeed()
{
	const ULPUserSettings* Settings = GetDefault<ULPUserSettings>();
	return Settings->bCameraSpeedSet ? ClampCameraSpeed(Settings->CameraSpeed) : LPUserSettingsGi::DefaultCameraSpeed;
}
```

### Commandes de contrôle rejouables
- `git -C "D:/Game/LifePlay-master 5.8" status --short` → ` M Source/LifePlay/LPSettingsSubsystem.cpp`, `?? Source/LifePlay/LPUserSettings.cpp`,
  `?? Source/LifePlay/LPUserSettings.h` (+ `?? Docs/Migration/32_Organisation_Agents.md`, préexistant, non touché).
- `git -C "D:/Game/LifePlay-master 5.8" ls-files --eol -- Source/LifePlay/LPSettingsSubsystem.cpp` → `i/crlf w/crlf` ;
  `git … ls-files -o --eol -- Source/LifePlay/` → `w/lf` pour les deux neufs.

## Addendum orchestrateur (2026-10-10, après remise du livrable)
Écart E2 tranché : le style ne s'applique qu'au slider `SliderCameraSpeed` (les sliders `LPColor*` / `LPVideo*` gardent
leur aspect). Code actuel de la boucle : `if (!Slider || Slider->GetFName() != TEXT("SliderCameraSpeed")) { continue; }` et
commentaire « slider de vitesse de camera seulement ». MD5 actuel de `LPSettingsSubsystem.cpp` : `b72671af…` (le MD5
`ede28e6d…` cité plus haut est celui de la version remise par lp-impl). Le diff de ce livrable décrit la version
antérieure ; la version qui fait foi est celle relue en STC-VAL (contrôle a).