Init

2026-01-20 20:33:59 +01:00
commit b16a40e431
583 changed files with 87339 additions and 0 deletions
--- a/content/ui-systems/permissions/_index.fr.md
+++ b/content/ui-systems/permissions/_index.fr.md
@@ -0,0 +1,349 @@
+---
+title: Système de Permissions
+type: docs
+weight: 12
+---
+
+Le système de Permissions fournit un contrôle d'accès granulaire pour les commandes, les fonctionnalités de l'éditeur et les fonctionnalités personnalisées des plugins.
+
+**Package:** `com.hypixel.hytale.server.core.permissions`
+
+## Vue d'Ensemble
+
+Hytale utilise un système de permissions avec :
+- **Permissions utilisateur** - Directement assignées aux joueurs individuels
+- **Permissions de groupe** - Héritées par tous les membres d'un groupe
+- **Fournisseurs de permissions** - Logique personnalisée pour les permissions dynamiques
+
+## Accéder au Module de Permissions
+
+```java
+import com.hypixel.hytale.server.core.permissions.PermissionsModule;
+
+// Utiliser la méthode statique get() - PAS HytaleServer.get().getPermissionsModule()
+PermissionsModule permissions = PermissionsModule.get();
+```
+
+## Vérifier les Permissions
+
+```java
+UUID playerUuid = player.getPlayerRef().getUuid();
+
+// Vérifier si le joueur a la permission
+boolean canEdit = permissions.hasPermission(playerUuid, "hytale.editor.asset");
+
+// Vérifier dans le contexte de commande
+if (permissions.hasPermission(ctx.sender().getUuid(), "myplugin.admin")) {
+    // Logique réservée aux admins
+}
+```
+
+## Permissions Utilisateur
+
+Gérer les permissions pour les joueurs individuels :
+
+```java
+UUID playerUuid = player.getPlayerRef().getUuid();
+
+// Ajouter des permissions
+permissions.addUserPermission(playerUuid, Set.of(
+    "myplugin.feature.create",
+    "myplugin.feature.delete"
+));
+
+// Supprimer des permissions
+permissions.removeUserPermission(playerUuid, Set.of(
+    "myplugin.feature.delete"
+));
+```
+
+## Permissions de Groupe
+
+Les groupes permettent de partager des permissions entre plusieurs joueurs :
+
+### Gérer les Groupes
+
+```java
+// Ajouter un joueur à un groupe
+permissions.addUserToGroup(playerUuid, "moderators");
+
+// Retirer un joueur d'un groupe
+permissions.removeUserFromGroup(playerUuid, "moderators");
+
+// Obtenir tous les groupes d'un joueur
+Set<String> groups = permissions.getGroupsForUser(playerUuid);
+```
+
+### Événements de Permissions de Groupe
+
+Écouter les changements de groupes en utilisant des sous-classes spécifiques :
+
+```java
+import com.hypixel.hytale.server.core.event.events.permissions.*;
+
+// Joueur AJOUTÉ à un groupe
+getEventRegistry().register(PlayerGroupEvent.Added.class, event -> {
+    UUID playerUuid = event.getPlayerUuid();
+    String group = event.getGroupName();  // Note: getGroupName(), PAS getGroup()
+    log("Joueur a rejoint le groupe : " + group);
+});
+
+// Joueur RETIRÉ d'un groupe
+getEventRegistry().register(PlayerGroupEvent.Removed.class, event -> {
+    UUID playerUuid = event.getPlayerUuid();
+    String group = event.getGroupName();
+    log("Joueur a quitté le groupe : " + group);
+});
+
+// Permissions du groupe AJOUTÉES
+getEventRegistry().register(GroupPermissionChangeEvent.Added.class, event -> {
+    String group = event.getGroupName();
+    Set<String> added = event.getAddedPermissions();
+    log("Groupe " + group + " a reçu les permissions : " + added);
+});
+
+// Permissions du groupe RETIRÉES
+getEventRegistry().register(GroupPermissionChangeEvent.Removed.class, event -> {
+    String group = event.getGroupName();
+    Set<String> removed = event.getRemovedPermissions();
+    log("Groupe " + group + " a perdu les permissions : " + removed);
+});
+
+// Permissions du joueur AJOUTÉES
+getEventRegistry().register(PlayerPermissionChangeEvent.PermissionsAdded.class, event -> {
+    UUID playerUuid = event.getPlayerUuid();
+    Set<String> added = event.getAddedPermissions();
+});
+
+// Permissions du joueur RETIRÉES
+getEventRegistry().register(PlayerPermissionChangeEvent.PermissionsRemoved.class, event -> {
+    UUID playerUuid = event.getPlayerUuid();
+    Set<String> removed = event.getRemovedPermissions();
+});
+```
+
+## Permissions Intégrées
+
+Hytale inclut de nombreuses permissions intégrées :
+
+### Permissions de Commandes
+
+| Permission | Description |
+|------------|-------------|
+| `hytale.command.*` | Accès à toutes les commandes |
+| `hytale.command.gamemode` | Changer de mode de jeu |
+| `hytale.command.tp` | Téléportation |
+| `hytale.command.give` | Donner des objets |
+| `hytale.command.time` | Contrôle du temps |
+
+### Permissions de l'Éditeur
+
+| Permission | Description |
+|------------|-------------|
+| `hytale.editor.asset` | Édition des assets |
+| `hytale.editor.packs.*` | Gestion des packs |
+| `hytale.editor.builderTools` | Accès aux outils de construction |
+| `hytale.editor.brush.*` | Outils de pinceau |
+| `hytale.editor.prefab.*` | Édition des prefabs |
+| `hytale.editor.selection.*` | Outils de sélection |
+| `hytale.editor.history` | Historique annuler/rétablir |
+
+### Permissions de Caméra
+
+| Permission | Description |
+|------------|-------------|
+| `hytale.camera.flycam` | Mode caméra libre |
+
+## Fournisseur de Permission Personnalisé
+
+Implémentez `PermissionProvider` pour une logique de permission dynamique :
+
+{{< callout type="info" >}}
+**Note :** `PermissionProvider` est une interface qui fournit des ensembles de permissions, pas une simple vérification hasPermission. Le `PermissionsModule` vérifie ces ensembles.
+{{< /callout >}}
+
+```java
+import com.hypixel.hytale.server.core.permissions.provider.PermissionProvider;
+
+public class VIPPermissionProvider implements PermissionProvider {
+    private final Map<UUID, Set<String>> vipPermissions = new ConcurrentHashMap<>();
+    private final Map<UUID, Set<String>> vipGroups = new ConcurrentHashMap<>();
+
+    @Override
+    @Nonnull
+    public String getName() {
+        return "VIPPermissionProvider";
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Retourner les permissions pour cet utilisateur
+        // Les utilisateurs VIP reçoivent des permissions supplémentaires automatiquement
+        if (isVIP(uuid)) {
+            Set<String> perms = new HashSet<>(vipPermissions.getOrDefault(uuid, Collections.emptySet()));
+            perms.add("vip.lounge");
+            perms.add("vip.cosmetics");
+            return perms;
+        }
+        return vipPermissions.getOrDefault(uuid, Collections.emptySet());
+    }
+
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        vipPermissions.computeIfAbsent(uuid, k -> new HashSet<>()).addAll(permissions);
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        Set<String> userPerms = vipPermissions.get(uuid);
+        if (userPerms != null) {
+            userPerms.removeAll(permissions);
+        }
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {}
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {}
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        return vipGroups.getOrDefault(uuid, Collections.emptySet());
+    }
+
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        vipGroups.computeIfAbsent(uuid, k -> new HashSet<>()).add(group);
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        Set<String> groups = vipGroups.get(uuid);
+        if (groups != null) {
+            groups.remove(group);
+        }
+    }
+
+    private boolean isVIP(UUID uuid) {
+        // Votre logique de vérification VIP
+        return vipDatabase.contains(uuid);
+    }
+}
+```
+
+### Enregistrer des Fournisseurs Personnalisés
+
+```java
+@Override
+public void start() {
+    PermissionsModule permissions = PermissionsModule.get();
+    permissions.addProvider(new VIPPermissionProvider());
+}
+```
+
+## Wildcards de Permission
+
+Les permissions supportent les correspondances avec wildcard :
+
+```java
+// Accorder toutes les permissions sous un namespace
+permissions.addUserPermission(playerUuid, Set.of("myplugin.*"));
+
+// Ceci passe maintenant :
+permissions.hasPermission(playerUuid, "myplugin.anything");
+permissions.hasPermission(playerUuid, "myplugin.feature.nested");
+```
+
+## Intégration des Permissions de Commandes
+
+Les commandes vérifient automatiquement les permissions basées sur leur ID :
+
+```java
+public class AdminCommand extends AbstractCommand {
+
+    public AdminCommand() {
+        super("admin", "myplugin.commands.admin.description");
+        // La vérification de permission est automatique basée sur l'enregistrement de la commande
+    }
+
+    @Override
+    protected CompletableFuture<Void> execute(CommandContext ctx) {
+        // Seuls les joueurs avec la permission appropriée arrivent ici
+        return null;
+    }
+}
+```
+
+## Exemples Pratiques
+
+### Accès Basé sur les Rôles
+
+```java
+public class RoleManager {
+    private final PermissionsModule permissions;
+
+    public RoleManager() {
+        this.permissions = PermissionsModule.get();
+    }
+
+    public void promoteToModerator(UUID playerUuid) {
+        permissions.addUserToGroup(playerUuid, "moderators");
+        permissions.addUserPermission(playerUuid, Set.of(
+            "server.kick",
+            "server.mute",
+            "server.warn"
+        ));
+    }
+
+    public void demoteFromModerator(UUID playerUuid) {
+        permissions.removeUserFromGroup(playerUuid, "moderators");
+        permissions.removeUserPermission(playerUuid, Set.of(
+            "server.kick",
+            "server.mute",
+            "server.warn"
+        ));
+    }
+
+    public boolean canModerate(UUID playerUuid) {
+        return permissions.getGroupsForUser(playerUuid).contains("moderators");
+    }
+}
+```
+
+### Verrouillage de Fonctionnalités
+
+```java
+public void useFeature(Player player, String featureName) {
+    UUID uuid = player.getPlayerRef().getUuid();
+    PermissionsModule perms = PermissionsModule.get();
+
+    String permission = "myplugin.feature." + featureName;
+    if (!perms.hasPermission(uuid, permission)) {
+        player.sendMessage(Message.translation("error.no_permission"));
+        return;
+    }
+
+    // Exécuter la fonctionnalité
+    executeFeature(player, featureName);
+}
+```
+
+## Bonnes Pratiques
+
+{{< callout type="info" >}}
+**Directives des Permissions :**
+- Utilisez des permissions avec namespace (ex: `myplugin.feature.name`)
+- Préférez les groupes pour l'accès basé sur les rôles plutôt que les permissions individuelles
+- Vérifiez les permissions aux points d'entrée, pas profondément dans la logique
+- Utilisez les wildcards avec parcimonie et intentionnellement
+{{< /callout >}}
+
+{{< callout type="warning" >}}
+**Note de Sécurité :** Validez toujours les permissions côté serveur. Ne faites jamais confiance aux états de permission rapportés par le client.
+{{< /callout >}}