Plugin Fiche joueur

[Frithy]

Bonjour,

J'aimerai faire une "fiche" pour chaque joueur qui se connecte à mon serveur, mais je ne sais pas comment m'y prendre pour faire ça et les enregistrer.

Pouvez-vous m'aider ?

Merci

 

[ShE3py]

Bonsoir,

Qu'entends-tu par une fiche ? Ajouter des données personnalisées aux joueurs ?

Cordialement,
ShE3py.

 

[Frithy]

Bonsoir,

Qu'entends-tu par une fiche ? Ajouter des données personnalisées aux joueurs ?

Cordialement,
ShE3py.

Oui c'est ça, pour que ce que je lui donne comme valeur ne soit que pour lui

 

[ShE3py]

Le plus simple est de passer par un tableau associatif, le principe est le même que pour une liste sauf qu'au lieu de récupérer un élément par son indice on le récupère par un objet.

Exemple :

// Map<Clef, Valeur>
Map<String, String> capitalCities = new HashMap<String, String>();

// Map#put(Clef, Valeur)
capitalCities.put("Germany", "Berlin");
capitalCities.put("Israel", "Jerusalem");
capitalCities.put("Palestine", "Jerusalem");
capitalCities.put("France", "Paris");
capitalCities.put("Italy", "Rome");

// Map#get(Clef) → Valeur
String baguette = capitalCities.get("France");

// baguette == "Paris"

En l'occurrence pour la clef, on peut prendre soit Player soit UUID.
Avant la 1.8 l'on prenait le nom du joueur comme clef, mais depuis la 1.8 puisque les joueurs peuvent changer de nom, pour éviter que tout leur inventaire soit perdu chaque compte Minecraft a un Universally Unique IDentifier associé, qui ne changera jamais.

public class PlayerData {
    private static final Map<UUID, PlayerData> PLAYER_DATAS = new HashMap<>();
    
    public final UUID uuid;
    public int myValue;
    
    public PlayerData(UUID uuid, int myValue) {
        this.uuid = uuid;
        this.myValue = myValue;
    }
    
    public PlayerData(UUID uuid) {
        this(uuid, 0);
    }
    
    public static PlayerData getPlayerData(UUID uuid) {
        if(!PLAYER_DATAS.containsKey(uuid))
            PLAYER_DATAS.put(uuid, new PlayerData(uuid));
        
        return PLAYER_DATAS.get(uuid);
        
        
        // en une ligne:
        return PLAYER_DATAS.computeIfAbsent(uuid, PlayerData::new);
    }
    
    public static PlayerData getPlayerData(OfflinePlayer player) {
        return getPlayerData(player.getUniqueID());
    }
}

Tu peux accéder à myValue de cette manière :

@EventHandler
public void example(PlayerJoinEvent event) {
    Player player = event.getPlayer();
    PlayerData data = PlayerData.getPlayerData(player);
    data.myValue = 5;
}

À toi après de t'occuper de la sauvegarde des données.

La javadoc :
https://docs.oracle.com/javase/8/docs/api/java/util/Map.html (en)

Pour les différences entre les différentes implémentations des Maps :
https://www.jmdoudoux.fr/java/dej/chap-collections.htm#collections-5 (fr)

N'hésite pas si tu as des questions.

 

[Frithy]

Merci pour tout ça j'y avais pas penser, ma "fiche" joueur possède le joueur et 4 5 autres valeurs.

Il est mieux de procédé avec une Map qui contient UUID du joueur et un tableau de valeur ?

Ou il y a une autre collection permetant de faire ça car je sais d'expérience que de faire une Map à 3 colonnes est super compliqué à gérer par la suite.

Autant pour moi je pense avoir trouvé un moyen pour en faisant une Map dans une autre mais faut que je réfléchisse pour l'initialisation et le remplissage.

 

[ShE3py]

Bah enfaite, il suffit juste de rajouter des variables à PlayerData, et tu peux récupérer le joueur à partir de son UUID.
Puisque les valeurs sont uniques, il suffit juste de créer une nouvelle classe PlayerData pour avoir autant de valeurs que l'on souhaite.

public class PlayerData {
    private static final Map<UUID, PlayerData> PLAYER_DATAS = new HashMap<>();
    
    public final UUID uuid;
    public int foo;
    public int bar;
    public int baz;
    public float qux;
    public float quux;
    
    private PlayerData(UUID uuid, int foo, int bar, int baz, float qux, float quux) {
        this.uuid = uuid;
        this.foo = foo;
        this.bar = bar;
        this.baz = baz;
        this.qux = qux;
        this.quux = quux;
    }
    
    private PlayerData(UUID uuid) {
        this(uuid, 0, 0, 0, 0f, 0f);
    }
    
    public static PlayerData from(UUID uuid) {
        return PLAYER_DATAS.computeIfAbsent(uuid, PlayerData::new);
    }
    
    public static PlayerData from(OfflinePlayer player) {
        return from(player.getUniqueId());
    }
    
    public OfflinePlayer getOfflinePlayer() {
        return Bukkit.getOfflinePlayer(uuid);
    }
    
    // java.util.Optional<T>
    public Optional<Player> getPlayer() {
        return Optional.ofNullable(Bukkit.getPlayer(uuid));
    }
}


// Example

@EventHandler
public void gimmePlayer(PlayerJoinEvent event) {
    PlayerData data = PlayerData.from(event.getPlayer());
    
    Player fromData = data.getPlayer().get();
    
    System.out.println(fromData.getName());
    System.out.println(data.uuid);
    System.out.println(data.foo);
    System.out.println(data.bar);
    System.out.println(data.baz);
    System.out.println(data.qux);
    System.out.println(data.quux);
}

 

[Frithy]

Hmmm j'arrive pas a avancé je vais redonner mon idée de ce que je veux faire parce que je me suis très mal exprimé.

J'ai fais ce que j'ai pu pour le schéma. Mais ça donne l'idée général.

 

[ShE3py]

Bah il suffit de mettre une map en plus dans PlayerData.

public class PlayerData {
   private static final Map<UUID, PlayerData> PLAYER_DATAS = new HashMap<>();
   
   public final UUID uuid;
   private final Map<Drug, DrugEntry> drugs = new EnumMap<>(Drug.class);
   
   private PlayerData(UUID uuid) {
      this.uuid = uuid;
   }
   
   private PlayerData(UUID uuid, Map<Drug, DrugEntry> drugs) {
      this(uuid);
      
      this.drugs.putAll(drugs);
   }
   
   private PlayerData(UUID uuid, List<DrugEntry> drugs) {
      this(uuid);
      
      drugs.forEach(entry -> this.drugs.put(entry.drug, entry));
   }
   
   public static PlayerData from(UUID uuid) {
      return PLAYER_DATAS.computeIfAbsent(uuid, PlayerData::new);
   }
   
   public static PlayerData from(OfflinePlayer player) {
      return from(player.getUniqueId());
   }
   
   public OfflinePlayer getOfflinePlayer() {
      return Bukkit.getOfflinePlayer(uuid);
   }
   
   // java.util.Optional<T>
   public Optional<Player> getPlayer() {
      return Optional.ofNullable(Bukkit.getPlayer(uuid));
   }
   
   public Collection<DrugEntry> getDrugEntries() {
      return Collections.unmodifiableCollection(drugs.values());
   }
   
   public DrugEntry getDrugEntry(Drug drug) {
      return drugs.computeIfAbsent(drug, DrugEntry::new);
   }
   
   public boolean removeDrugEntry(Drug drug) {
      return drugs.remove(drug) != null;
   }
}

public enum Drug {
   COCAINE("Cocaïne"),
   AMPHETAMINE("Amphétamine");
   
   public final String name;
   
   private Drug(String name) {
      this.name = name;
   }
}

public class DrugEntry {
   public final Drug drug;
   public int addiction;
   public int withdrawal;
   public float overdose;
   
   public DrugEntry(Drug drug, int addiction, int withdrawal, float overdose) {
      this.drug = drug;
      this.addiction = addiction;
      this.withdrawal = withdrawal;
      this.overdose = overdose;
   }
   
   public DrugEntry(Drug drug) {
      this(drug, 0, 0, 0f);
   }
}