Files

T

Mathew 176beab9fc (Feat) Add footsteps

2026-08-11 15:23:10 +02:00

23 KiB

Raw Permalink Blame History

Coffres

Contenants posés dans le monde : on les ouvre, on y range, on y reprend. Le couvercle se lève pour tout le monde, le contenu est partagé et accessible à plusieurs en même temps.

Fichiers : StorageContainer.h/.cpp, plus le panneau de coffre d'InventoryScreenWidget, l'API de transfert d'InventoryComponent et le bloc UI|Storage de FpsPlayerController.

1. Le principe

Un coffre n'a aucun modèle de données à lui. Son contenu est un UInventoryComponent, exactement le même que celui du joueur, simplement configuré sans barre rapide. Tout le reste en découle :

le glisser-déposer entre le sac et le coffre ne convertit rien — ce sont les mêmes cases, le même FInventorySlot ;
la durabilité d'une hache traverse le coffre sans une ligne de code, puisque l'usure vit sur le slot ;
il n'y a pas de « format coffre » à faire évoluer le jour où l'inventaire change.

Le coffre ne décide de rien. Il se contente d'appeler OpenStorage(this) sur le controller. C'est ce dernier qui referme le couvercle — par Échap, par la mort du joueur, ou parce qu'il s'est éloigné. Un coffre qui déciderait seul finirait ouvert dans la moitié des cas, et il n'a de toute façon aucun moyen de savoir que l'écran s'est fermé.

Ce n'est pas un écran à part, c'est un panneau de plus sur WBP_InventoryScreen — voir §5.

2. L'acteur `AStorageContainer`

2.1 Composants

Composant	Rôle
`BaseMesh`	La caisse : `SM_Chest_Bottom`. Racine, purement visuelle, collision désactivée
`InteractionBox`	L'unique collision du coffre. Fille de la caisse
`LidMesh`	Le couvercle : `SM_Chest_Top`. Enfant direct de la caisse, collision désactivée
`Storage`	Le contenu. Un `UInventoryComponent` ordinaire

2.2 Réglages exposés

Catégorie Storage

Propriété	Défaut	Effet
`SlotCount`	20	Nombre de cases. Réglable par instance : le même Blueprint donne un petit coffre de 12 et un grand de 30
`ColumnCount`	6	Cases par ligne dans l'écran. Purement visuel
`DisplayName`	`Chest`	Titre affiché au-dessus de la grille
`InteractionPrompt`	`Ouvrir le coffre`	Texte affiché quand le joueur vise
`StartingItems`	—	Contenu versé une seule fois au `BeginPlay`

StartingItems est de la donnée de level design, pas du gameplay : un coffre de départ, une cache à trouver. Ce qui ne rentre pas part dans l'Output Log en warning plutôt que de disparaître en silence.

Catégorie Storage|Collision

Propriété	Défaut	Effet
`bAutoFitInteractionBox`	☑	La boîte épouse seule les deux meshes, couvercle fermé
`InteractionBoxPadding`	0 cm	Marge additive autour du volume trouvé

Catégorie Storage|Lid

Propriété	Défaut	Effet
`OpenRotation`	`(-100, 0, 0)`	Rotation relative du couvercle ouvert. Le repos vaut toujours zéro
`LidDuration`	0.35 s	Durée de l'ouverture

Catégorie Storage|Sound — OpenSound, CloseSound. Facultatifs : un champ vide ne joue rien.

2.3 API publique

void  SetOpen(bool bInOpen);          // SERVEUR uniquement. Lève ou rabat le couvercle
bool  IsOpen() const;
UInventoryComponent* GetStorage() const;
FText GetDisplayName() const;
int32 GetColumnCount() const;

SetOpen est appelée par le controller, pas par le coffre : lui seul sait quand l'écran se referme.

3. Le couvercle

3.1 La rotation se fait sur le pivot du mesh

C'est LidMesh lui-même qu'on tourne, et un UStaticMeshComponent pivote toujours autour de l'origine de son mesh. La charnière est donc celle que l'artiste a donnée à SM_Chest_Top — rien à placer, rien à régler.

Un SceneComponent vide LidPivot a existé entre la caisse et le couvercle, pour découpler la charnière du pivot du pack. Il a été retiré : il fallait le placer à la main dans chaque Blueprint, et laissé à (0,0,0) il faisait tourner le couvercle autour du centre de la caisse — c'est-à-dire à travers elle. C'était le symptôme, pas une configuration exotique.

Corollaire assumé : si un pack livre un couvercle dont le pivot est au centre, on corrige l'asset, pas le code — Modeling Mode > XForm > Edit Pivot sur le Static Mesh, pivot posé sur l'arête arrière, Accept. C'est payé une fois par pack de coffre.

OpenRotation est un FRotator complet et pas un simple angle : selon l'orientation dans laquelle le mesh a été exporté, la charnière peut tomber sur le pitch, le yaw ou le roll. On règle les trois à l'œil dans le viewport plutôt que d'aller comprendre quel axe local du mesh pointe où.

3.2 L'animation

Un Tick, mais éteint au repos (bStartWithTickEnabled = false). ApplyOpenState() le rallume, et le tick s'éteint lui-même en fin de course.

LidAlpha = FMath::FInterpConstantTo(LidAlpha, Target, DeltaTime, 1.f / LidDuration);
const float Eased = FMath::SmoothStep(0.f, 1.f, LidAlpha);
LidMesh->SetRelativeRotation(OpenRotation * Eased);

SmoothStep : un couvercle à vitesse constante démarre et s'arrête d'un coup, ce qui se lit comme une saccade sur un objet lourd.
L'alpha repart de sa valeur courante, donc refermer un coffre à moitié ouvert ne saute pas.
La valeur exacte est forcée avant de se rendormir. Sans ça le couvercle resterait à un poil de sa position finale pour le reste de la partie.
BeginPlay repose l'alpha à zéro quelle que soit la rotation laissée dans le Blueprint : le repos est la référence de l'animation. Une rotation authorée sur LidMesh serait donc perdue au lancement.

4. La collision — une seule boîte

Les deux meshes n'en portent aucune. C'est la seule exception à la règle « le mesh EST la surface d'interaction » posée par ACraftingStation, et elle vient de ce qu'un coffre est en deux morceaux dont un tourne :

compter sur les collisions des meshes imposerait que le pack en fournisse deux correctes ;
et laisserait surtout un trou dans la surface visable dès que le couvercle se lève — viser le haut d'un coffre ouvert ne toucherait plus rien.

La boîte est fille de la caisse, jamais du couvercle : le coffre se vise exactement au même endroit ouvert et fermé. Sinon le prompt disparaîtrait au moment précis où l'on s'en sert.

Son profil est BlockAll, posé explicitement : elle a deux rôles indissociables, empêcher le joueur de traverser le coffre et bloquer le canal Visibility pour que le trace d'interaction la trouve. Un profil qui laisserait passer Visibility rendrait le coffre inutilisable sans qu'aucune erreur ne le signale.

`FitInteractionBox()` — deux pièges

Appelée depuis OnConstruction, donc elle tourne aussi dans l'éditeur : changer de variante de coffre recale la boîte à l'instant, sans lancer le jeu.

Lire les bounds de l'ASSET (UStaticMesh::GetBoundingBox()), pas Mesh->Bounds — ces dernières sont déjà multipliées par l'échelle, que SetBoxExtent remultiplie.
Composer avec la transform RELATIVE à la racine, pas la transform monde : la boîte doit rester juste où que l'acteur soit posé dans le niveau.

Même paire de pièges que dans APickupItem::FitInteractionBox.

5. L'écran

5.1 Un panneau, pas un écran

Le contenu du coffre s'affiche à côté de la grille du joueur, sur WBP_InventoryScreen, comme frère du WidgetSwitcher et Collapsed par défaut.

La raison est du ressenti pur : le sac du joueur ne bouge pas d'un pixel entre « j'ouvre mon sac » et « j'ouvre un coffre ». Un écran distinct le ferait sauter à chaque fois.

Ce n'est pas non plus un troisième onglet : les deux grilles doivent être visibles ensemble, ce qu'un WidgetSwitcher interdit par construction.

5.2 C'est une deuxième instance du même `WBP_Inventory`

Elle ne peut pas vivre dans WBP_Inventory — un Widget Blueprint qui se contient lui-même est une référence circulaire, et UMG refuse de le compiler. D'où deux conséquences directes :

bAutoBindToPawn doit être DÉCOCHÉ sur la grille de coffre. Sans ça elle s'accroche au pawn dans son NativeConstruct — qui s'exécute avant que l'écran ait eu le temps de lui donner le conteneur — et le sac du joueur s'affiche des deux côtés.
Le panneau de détail est coupé par le code, jamais par une case à cocher (SetItemDetailsEnabled). Un réglage par instance serait un bug qui attend qu'on oublie de le décocher sur l'une des deux.

5.3 Ce que l'écran fait à l'ouverture


`StorageGrid->SetColumnCount`	La forme vient du coffre posé dans le niveau, pas du Widget Blueprint
`StorageGrid->BindToInventory`	Branche la grille sur le contenu
Cibles de clic droit croisées	Sac → coffre et coffre → sac (§6.2)
`InventoryPage->SetItemDetailsEnabled(false)`	Le sac perd son panneau de détail : trois colonnes seraient illisibles
`ShowInventoryTab()`	Un coffre ouvert sous l'onglet Fabrication n'aurait aucun sens

Et l'onglet Fabrication est grisé tant qu'un coffre est ouvert : le panneau étant frère du WidgetSwitcher, il resterait affiché à côté de la grille de recettes. La touche de craft, elle, rend le coffre plutôt que d'ignorer l'appui — la touche exprime une intention claire.

HideStorage() est appelée dès NativeConstruct : l'état par défaut est reposé à chaque construction plutôt qu'hérité de la Designer ou de la session précédente. Elle coupe aussi les transferts rapides avant de débrancher — une case qui garderait le coffre en mémoire y enverrait encore des objets au prochain clic droit, panneau fermé.

Tous les éléments de coffre sont en BindWidgetOptional : l'écran doit rester valide dans un projet où le panneau n'a pas encore été construit, sinon ajouter les coffres casserait la compilation de WBP_InventoryScreen — et donc l'inventaire entier.

6. Les transferts

6.1 Un seul déplacement pour tout

static bool TransferSlot(UInventoryComponent* From, int32 FromIndex,
                         UInventoryComponent* To,   int32 ToIndex, int32 Quantity);

Statique, parce qu'elle n'appartient ni à la source ni à la destination : elle arbitre entre les deux. MoveItem() et MoveItemQuantity() ne sont plus que des appels avec From == To.

Elle diffuse OnInventoryChanged des deux côtés. Oublier la seconde diffusion laisse la grille d'en face afficher un état périmé jusqu'au prochain événement, ce qui se lit comme un objet qui disparaît.

6.2 Clic droit = envoyer en face

QuickTransferSlot() passe par AddItem(), donc exactement comme un ramassage : piles entamées d'abord, puis barre rapide, puis grille. Ce qui ne rentre pas reste sur place.

La destination est poussée par l'écran (SetQuickTransferTarget), jamais devinée. Hors de l'écran de coffre il n'existe aucun « autre côté », et deviner ferait disparaître des objets. La barre rapide reçoit elle aussi le coffre, pour que le clic droit y marche par-dessus l'écran.

6.3 « Tout ranger » / « Tout prendre »

int32 TransferAllTo(UInventoryComponent* To, int32 FirstIndex = 0);

Tout ranger part de GetBackpackStartIndex() : la barre rapide porte les outils qu'on vient d'utiliser, les ranger d'office serait une punition déguisée en confort.
Tout prendre part de l'index 0 — un coffre n'a pas de barre rapide. Ce qui ne rentre pas dans le sac reste dans le coffre.

7. Le cycle d'ouverture

Le controller est le seul maître. ReleaseActiveStorage() est le point de sortie unique : toute fermeture d'écran y passe, quelle qu'en soit la cause.

Déclencheur	Chemin
Interagir avec le coffre	`Interact_Implementation` → `OpenStorage()`
Échap	`HandlePauseInput()` — le coffre passe avant l'inventaire
Tab	`SetInventoryScreenOpen(false)`
Touche de craft	Rend le coffre, puis affiche l'onglet Fabrication
Mort du joueur	Fermeture de l'écran
Éloignement	`CheckStorageDistance()`, timer à 0,25 s
Coffre détruit	Idem, la `TWeakObjectPtr` est nulle
Ouvrir un autre coffre	`OpenStorage()` rend le précédent avant

MaxStorageDistance (400 cm) : sans elle on viderait un coffre depuis l'autre bout de la carte, rien n'obligeant le joueur à rester devant une fois l'écran ouvert. Surveillée par un timer, jamais un Tick, et seulement pendant que l'écran est ouvert — un timer permanent pour une condition vraie deux minutes par partie serait du gaspillage. DistSquared, pour ne pas prendre une racine carrée quatre fois par seconde.

Le timer est aussi nettoyé à la destruction du HUD : il rappellerait une méthode d'un controller en train de disparaître.

8. Réseau

Autorité serveur sur tout, comme pour le reste du monde.

Élément	Réplication
`bOpen`	`ReplicatedUsing = OnRep_Open` — voir le couvercle d'un coffre se lever est le seul signe qu'un coéquipier fouille dedans
`Slots` du conteneur	Répliqué à tout le monde par `UInventoryComponent`
L'animation, le son	Rien : dérivés de `bOpen` des deux côtés par `ApplyOpenState()`

Les quatre pièges

Interact_Implementation s'exécute sur le SERVEUR. PlayerController->OpenStorage(...) y créerait un widget dans le vide. D'où Client_OpenStorage : le serveur lève le couvercle (état du monde) et renvoie l'ordre d'écran au client. C'est le piège le plus contre-intuitif du portage, parce que le code semble correct et marche parfaitement chez l'hôte.
SetOpen ne fait rien sans autorité. Chez un client, refermer l'écran doit passer par Server_ReleaseStorage — sinon le coffre resterait ouvert pour les trois autres joueurs alors que l'écran est fermé ici.
FindNetProxy est le passage obligé des transferts. Un UInventoryComponent de coffre n'appartient à aucune connexion : une RPC émise depuis lui est silencieusement jetée. On route donc toujours par l'inventaire du pawn local, et la source comme la destination sont passées en paramètres — jamais déduites du récepteur, sinon « Tout prendre » viderait le sac du joueur dans lui-même.
Slots est répliqué à tout le monde, pas au seul propriétaire. Ce n'est pas un raccourci : les conditions de GetLifetimeReplicatedProps sont mises en cache par classe, pas par instance. Un COND_OwnerOnly frapperait donc aussi le composant du coffre — or un coffre n'appartient à personne, et sa grille n'arriverait chez aucun joueur.

Accès simultané, pas de verrou. Deux joueurs peuvent fouiller le même coffre : TransferSlot diffuse déjà OnInventoryChanged des deux côtés, et tous les widgets y sont abonnés. L'UI se recâble donc toute seule à chaque OnRep_Slots().

Pas de prédiction. Le client envoie sa RPC et attend la réplication. Quelques dizaines de millisecondes sur un relais Steam, invisibles pour un glisser-déposer, alors qu'une prédiction fausse donnerait une pile qui saute.

9. Guide éditeur

9.1 Le Blueprint du coffre

Content Browser → Content/Game/Building/Storage/ → clic droit → Blueprint Class → All Classes → StorageContainer → nomme-le BP_Chest_Wooden.
Ouvre-le. Sélectionne BaseMesh → Details → Static Mesh = SM_Chest_Bottom.
Sélectionne LidMesh → Static Mesh = SM_Chest_Top.
Toujours sur LidMesh, Details → Transform :
- Location : les deux meshes viennent du même export, donc 0, 0, 0 les repose l'un sur l'autre. Ajuste seulement s'il flotte ou s'enfonce.
- Rotation : 0, 0, 0 obligatoirement. BeginPlay écrase cette valeur — une rotation laissée ici serait perdue au lancement.
Sélectionne l'acteur racine (Self) → Details → Storage | Lid → Open Rotation. Le défaut est Pitch = -100. Tape des valeurs et regarde le viewport : si le couvercle bascule sur le côté, essaie le Roll, puis le Yaw.
Storage → règle Slot Count et Column Count. Mets un Display Name (« Coffre en bois ») et un Interaction Prompt.
Storage | Sound → Open Sound / Close Sound si tu en as.
Laisse Auto Fit Interaction Box coché : la boîte se cale seule sur les deux meshes. Vérifie-la avec Show > Collision dans le viewport.
Compile et Save.

Pose-le dans le niveau. Slot Count, Column Count, Display Name et Starting Items se règlent par instance dans le World Outliner : un seul Blueprint sert tous les coffres.

9.2 Le panneau de coffre dans `WBP_InventoryScreen`

À ne faire qu'une fois. Tout est en BindWidgetOptional, donc l'écran compile même à mi-chemin.

Ouvre WBP_InventoryScreen.
Dans la Designer, à côté du TabSwitcher — frère, pas enfant — pose un Horizontal Box ou une Border, et renomme-le StoragePanel. Mets sa Visibility à Collapsed (le code la repose de toute façon).
Dedans, un Vertical Box contenant :
- un Text Block nommé StorageTitle ;
- ton WBP_Inventory (Palette → User Created), renommé StorageGrid ;
- un Horizontal Box avec deux Button nommés StoreAllButton et TakeAllButton, chacun avec son Text Block (« Tout ranger », « Tout prendre »).
⚠ L'étape qu'on rate : sélectionne StorageGrid → Details → Inventaire → DÉCOCHE Auto Bind To Pawn.
Rappel : un Canvas Panel a une taille désirée de zéro. Si StoragePanel disparaît dans un conteneur en Auto, c'est ça — et un enfant en Size = Fill ne compte pas non plus dans la taille désirée de son parent.
Compile et Save.

9.3 Le controller

Un seul réglage : BP_FpsPlayerController → Details → UI | Storage → Max Storage Distance (400 cm par défaut). Rien d'autre à brancher, le coffre appelle OpenStorage lui-même.

9.4 Vérifier que ça marche

Vise le coffre : le prompt affiche ton Interaction Prompt, et au même endroit que le coffre soit ouvert ou fermé.
Interagis : le couvercle se lève en ~0,35 s, avec un départ et un arrêt adoucis, et l'écran d'inventaire s'ouvre avec le sac inchangé et le coffre à côté.
L'onglet Fabrication est grisé, et le panneau de détail du sac a disparu.
Glisse un objet du sac vers le coffre : Maj = la moitié, Ctrl = un seul.
Clic droit sur une case : elle part en face. Fais-le depuis la barre rapide aussi.
Tout ranger vide la grille mais laisse la barre rapide intacte.
Recule de plus de 4 m : l'écran se ferme seul et le couvercle se rabat.
Appuie sur la touche de craft coffre ouvert : le coffre est rendu et l'onglet Fabrication s'affiche.
En coop (build Steam) : l'autre joueur voit le couvercle se lever, et un objet déposé apparaît chez lui sans qu'il ait à refermer et rouvrir.

10. Dépannage

Symptôme	Cause
Le couvercle traverse la caisse / tourne de travers	Mauvais axe d'`Open Rotation`, ou pivot de `SM_Chest_Top` posé au centre du mesh — corrige-le dans Modeling Mode > XForm > Edit Pivot
Le couvercle est décalé de la caisse	`Location` de `LidMesh` (§9.1 étape 4)
Le couvercle saute au lancement	Une `Rotation` a été laissée sur `LidMesh` : `BeginPlay` la remet à zéro
Le coffre n'est pas visable	`Auto Fit Interaction Box` décoché avec une boîte restée minuscule, ou profil de collision changé
Le prompt disparaît une fois ouvert	La boîte a été reparentée sous `LidMesh` — elle doit rester fille de `BaseMesh`
Le sac du joueur s'affiche des deux côtés	`Auto Bind To Pawn` resté coché sur `StorageGrid`
Le panneau ne s'affiche pas du tout	`StoragePanel` ou `StorageGrid` mal nommé — l'Output Log le dit
Le panneau est là mais vide et plat	Canvas Panel dans un conteneur `Auto`, ou tous les enfants en `Fill`
Le coffre s'ouvre chez l'hôte, pas chez le client	`Client_OpenStorage` court-circuité, ou `Interact` appelé hors de `Execute_Interact`
Le couvercle reste levé chez les autres après fermeture	Chemin de sortie qui ne passe pas par `ReleaseActiveStorage()`
Un objet réapparaît après un transfert	Transfert exécuté côté client sans RPC — c'est la réplication qui le remet
« Tout prendre » vide le sac dans lui-même	Source déduite du récepteur au lieu d'être passée en paramètre
Les objets de départ manquent	`Slot Count` trop petit : le débordement part en warning dans l'Output Log

11. Étendre

Gratuit, sans une ligne de C++ :

D'autres coffres — le Blueprint est générique, seuls les meshes changent. La boîte d'interaction se recale seule.
Des tailles différentes — Slot Count par instance.
Un coffre-piège, une cache — Starting Items.

Ce qui demanderait du code :

La sauvegarde du contenu. C'est le chantier réel : Slots n'est pas sérialisé aujourd'hui. Le format est déjà le bon — le même FInventorySlot que le sac, donc une seule sérialisation servira les deux.
Les ressources du coffre comptant dans les recettes — c'est la raison pour laquelle l'onglet Fabrication est grisé plutôt que masqué : le jour où UCraftingComponent saura lire un inventaire voisin, il suffira de le dégriser.
Un cadenas, un propriétaire — il n'y a aujourd'hui aucun verrou, et c'est délibéré : coop entre amis.
Un coffre en un seul mesh (tonneau, sac) — la UBoxComponent reste valable, il suffit de laisser LidMesh vide et OpenRotation à zéro. FitInteractionBox ignore déjà un mesh absent.

12. Ce que ce système a changé ailleurs

UInventoryComponent::TransferSlot est devenue l'unique implémentation du déplacement. MoveItem / MoveItemQuantity ne sont plus que des appels avec From == To.
ConfigureAsContainer() : zéro barre rapide, donc GetBackpackStartIndex() vaut 0 et la grille affiche tout. Aucun nouveau modèle de données.
UInventoryWidget a perdu son lien vers sa grille parente : une case diffuse OnHoverChanged au lieu de connaître son propriétaire. Avec deux grilles à l'écran, l'index seul ne désignait plus rien de façon unique — d'où GetHoveredSlot(inventaire, index).
NativeOnMouseLeave n'arrive jamais quand un widget s'efface sous le curseur, ce qui est exactement ce qui se passe en fermant un coffre. D'où le passage obligé par SetHoveredSlot() dans ClearSlotWidgets() et BindToInventory() — cette dernière annonce la sortie avant de changer d'inventaire, sinon on ne sait plus quel affichage périmer.
SetItemDetailsEnabled sur la grille, piloté par l'écran et non par une case à cocher.

23 KiB Raw Permalink Blame History