Prefixes

Unterstützte Software

Software	Unterstützung
Paper und Forks	Vollständig, inkl. Folia
Minestom	Vollständig, als Library
Fabric	Geplant

Prefixes funktioniert mit und ohne SimpleCloud. Nur der Netzwerk-Sync braucht ein SimpleCloud-Netzwerk.

Plugin installieren

Paper
Minestom

Plugin installieren

Lade Prefixes von GitHub oder Modrinth herunter und leg die JAR in den plugins/ Ordner deines Server-Templates.Wenn du general.source: luckperms nutzen willst, installiere zusätzlich LuckPerms.

Konfiguration erzeugen

Starte einen passenden Server. Prefixes legt config.yml und messages.yml unter plugins/simplecloud-prefixes/ an.

Konfiguration ins Template übernehmen

Bei einem Gruppenserver kopierst du plugins/simplecloud-prefixes/ vom laufenden Server an denselben Pfad im Template, bevor der Server stoppt. Bearbeite danach die Kopie im Template.Wie das genau funktioniert, steht unter Templates.

Konfiguration anwenden und prüfen

Hast du die Dateien auf einem laufenden Server geändert, führ /scprefix reload aus. Hast du das Template bearbeitet, starte einfach einen neuen Server.

Join auf den Server und prüf, ob dein Gruppen-Prefix im Chat, in der Tablist und über deinem Kopf angezeigt wird.

Auf Minestom ist Prefixes eine Library, die du mit deinem Server auslieferst und im Code startest.

Dependency hinzufügen

Prefixes starten

Starte Prefixes nach MinecraftServer.init().

import app.simplecloud.prefixes.minestom.PrefixesMinestom
import net.minestom.server.MinecraftServer
import java.nio.file.Path

fun main() {
    val server = MinecraftServer.init()

    val prefixes = PrefixesMinestom.builder(Path.of("prefixes"))
        .permission { player, _ -> player.permissionLevel >= 4 }
        .enable()

    MinecraftServer.getSchedulerManager().buildShutdownTask { prefixes.shutdown() }
    server.start("0.0.0.0", 25565)
}

import app.simplecloud.prefixes.minestom.PrefixesMinestom;
import net.minestom.server.MinecraftServer;

import java.nio.file.Path;

public final class Server {
    public static void main(String[] args) {
        MinecraftServer server = MinecraftServer.init();

        PrefixesMinestom prefixes = PrefixesMinestom.builder(Path.of("prefixes"))
            .permission((player, permission) -> player.getPermissionLevel() >= 4)
            .enable();

        MinecraftServer.getSchedulerManager().buildShutdownTask(prefixes::shutdown);
        server.start("0.0.0.0", 25565);
    }
}

Ersetz den Permission-Check durch dein eigenes Permission-System. Der Builder hat diese Optionen:

Option	Standard	Beschreibung
`permission(check)`	Keiner	Entscheidet, welche Gruppe aus der Config ein Spieler bekommt und wer `/scprefix` nutzen darf.
`registerCommands(bool)`	`true`	Registriert den Befehl `/scprefix`.
`luckPerms(instance)`	`LuckPermsProvider.get()`	Setzt die LuckPerms-Instanz, falls sie nicht über den LuckPerms-Provider verfügbar ist.

Setup prüfen

Starte den Server und join. Dein Gruppen-Prefix wird im Chat, in der Tablist und über deinem Kopf angezeigt.

Konfiguration

Jeder Spieler gehört zu einer Gruppe, und die Gruppe bestimmt, wie er angezeigt wird. Prefixes holt sich die Gruppen aus der eigenen Config, aus LuckPerms oder von einem eigenen Group Provider.

config.yml

In der config.yml legst du fest, woher die Gruppen kommen, welche Gruppen es gibt, welche Features aktiv sind und wie der Sync zwischen Servern läuft.

# The config format version. Do not change this value.
version: 1

# ─────────────────────────────────────────────────────────────────────────────
# General
# Controls how player groups are resolved.
# ─────────────────────────────────────────────────────────────────────────────
general:
  # Where groups are loaded from.
  # Available: config, luckperms, or the name of a custom provider.
  source: config

  # Group used when a player matches no other group.
  # Must reference a group defined below when source is config.
  default-group: default

# ─────────────────────────────────────────────────────────────────────────────
# Features
# Each part of the plugin can be enabled independently.
# ─────────────────────────────────────────────────────────────────────────────
features:
  # Format chat messages using the group's chat-format.
  chat: true

  # Show the prefix, the colored player name and the suffix in the tab list,
  # sorted by group priority.
  tablist: true

  # Show the group's display-name above the player's head.
  # When disabled, the normal Minecraft name tag is shown instead.
  display-name: true

# ─────────────────────────────────────────────────────────────────────────────
# Sync
# Shares chat messages and tab list entries across the SimpleCloud network.
# ─────────────────────────────────────────────────────────────────────────────
sync:
  # Master switch for all cross-server communication.
  enabled: false

  # Select which features are synchronized.
  # The corresponding feature above must also be enabled.
  channels:
    chat: true
    tablist: true

  # Groups and persistent servers from which updates are received.
  #
  # Special values:
  #   CURRENT - Current server group, or this persistent server.
  #   ALL     - Every server in the network. Must be used alone.
  #
  # Literal SimpleCloud group names and persistent server IDs can also be used.
  # Multiple sources can be combined, except when using ALL.
  sources:
  - CURRENT

# ─────────────────────────────────────────────────────────────────────────────
# Groups
# Only used when general.source is config.
#
# Placeholders in display-name:
#   <prefix>       Group prefix
#   <suffix>       Group suffix
#   <color>        Group color
#   <playername>   Normal Minecraft player name
#
# Placeholders in chat-format:
#   <prefix>       Group prefix
#   <suffix>       Group suffix
#   <color>        Group color
#   <playername>   Normal Minecraft player name (alias: <name>)
#   <displayname>  Formatted display name
#   <message>      Chat message
#
# ─────────────────────────────────────────────────────────────────────────────
groups:
- name: owner
  # Higher priorities are selected first and sorted higher in the tab list.
  priority: 100
  # Permission required to use this group.
  permission: 'simplecloud.prefix.group.owner'
  prefix: '<#DC2626><bold>Owner</bold> <#475569>| '
  suffix: ''
  # Used by the <color> placeholder and player name coloring.
  color: '<#DC2626>'
  # Name shown above the player's head, e.g. '<prefix><color><playername>'.
  display-name: '<color><playername>'
  # Format used when features.chat is enabled.
  chat-format: '<prefix><color><playername><suffix> <#475569>» <#F8FAFC><message>'

- name: admin
  priority: 90
  permission: 'simplecloud.prefix.group.admin'
  prefix: '<#F59E0B><bold>Admin</bold> <#475569>| '
  suffix: ''
  color: '<#F59E0B>'
  display-name: '<color><playername>'
  chat-format: '<prefix><color><playername><suffix> <#475569>» <#F8FAFC><message>'

- name: default
  priority: 0
  # An empty permission matches every player.
  permission: ''
  prefix: '<#94A3B8>Player <#475569>| '
  suffix: ''
  color: '<#94A3B8>'
  display-name: '<color><playername>'
  chat-format: '<prefix><color><playername><suffix> <#475569>» <#F8FAFC><message>'

Gruppenquellen

Mit general.source legst du fest, woher die Gruppen kommen.

Source	Beschreibung
`config`	Nutzt die Gruppen unter `groups`.
`luckperms`	Nutzt die Gruppen aus LuckPerms. LuckPerms muss auf dem Server installiert sein.
Eigener Name	Nutzt einen Group Provider, den ein anderes Plugin über die API registriert.

LuckPerms-Mapping Mit source: luckperms liest Prefixes alles aus der LuckPerms-Gruppe. Von der Primärgruppe und den geerbten Gruppen eines Spielers gewinnt die mit dem höchsten Weight.

LuckPerms	Prefixes	Standard, wenn nicht gesetzt
Gruppenname	`name`	—
Weight	`priority`	`0`
Prefix	`prefix`	Leer
Suffix	`suffix`	Leer
Meta `color`	`color`	Weiß
Meta `display-name`	`display-name`	`<color><playername>`
Meta `chat-format`	`chat-format`	`<prefix><color><playername><suffix> <#475569>» <#F8FAFC><message>`

/lp group admin setweight 90
/lp group admin meta addprefix 90 "<#F59E0B><bold>Admin</bold> <#475569>| "
/lp group admin meta set color "<#F59E0B>"
/lp group admin meta set display-name "<prefix><color><playername>"
/lp group admin meta set chat-format "<prefix><color><playername><suffix> <#475569>» <#F8FAFC><message>"

Ändern sich die LuckPerms-Gruppen eines Spielers oder die Daten einer Gruppe, aktualisiert Prefixes den Spieler automatisch.

Platzhalter

Platzhalter	Verfügbar in	Beschreibung
`<prefix>`	`chat-format`, `display-name`	Prefix der Gruppe
`<suffix>`	`chat-format`, `display-name`	Suffix der Gruppe
`<color>`	`chat-format`, `display-name`	Farbe der Gruppe, wird als Style angewendet
`<playername>`	`chat-format`, `display-name`	Normaler Spielername
`<name>`	`chat-format`	Alias für `<playername>`
`<displayname>`	`chat-format`	Gerenderter Anzeigename des Spielers
`<message>`	`chat-format`	Die Chatnachricht

Nutz <color>, statt überall denselben Hex-Code zu schreiben. Der Platzhalter wird als Style angewendet, also übernimmt alles danach die Gruppenfarbe.

Features

Unter features schaltest du die einzelnen Teile des Plugins an oder aus:

chat formatiert Chatnachrichten mit dem chat-format der Gruppe
tablist zeigt Prefix, Spielernamen in der Gruppenfarbe und Suffix in der Tablist an, sortiert nach Priorität
display-name zeigt den display-name der Gruppe über dem Kopf des Spielers an. Ist es aus, siehst du den normalen Minecraft-Nametag

Netzwerk-Sync

Über das SimpleCloud-Netzwerk kann Prefixes zwei Dinge teilen:

Chat: Chatnachrichten von Spielern auf anderen Servern
Tablist: Tablist-Einträge von Spielern auf anderen Servern

Der Sync ist standardmäßig aus. Mit sync.enabled: true schaltest du ihn ein. Unter channels wählst du, ob Chat, Tablist oder beides geteilt wird. Ein Channel funktioniert nur, wenn das passende Feature unter features auch an ist. Über sources legst du fest, von welchen Servern dieser Server Updates bekommt:

CURRENT: von der eigenen Servergruppe bzw. bei einem Persistent Server nur von diesem Server
ALL: von allen Servern im Netzwerk. Muss der einzige Eintrag in der Liste sein
Name einer Servergruppe oder ID eines Persistent Servers: genau von dieser Quelle

Du kannst mehrere Gruppennamen und Server-IDs kombinieren. Sollen zwei Server sich gegenseitig Updates schicken, trag bei beiden jeweils die Gruppe oder ID des anderen ein.

Den Sync einschalten oder sync.sources ändern greift erst nach einem Neustart des Servers.

Befehle

Befehl	Permission	Beschreibung
`/scprefix`	`simplecloud.prefixes.command`	Zeigt die Befehlsübersicht.
`/scprefix help`	`simplecloud.prefixes.command`	Zeigt die Befehlsübersicht.
`/scprefix reload`	`simplecloud.prefixes.command.reload`	Lädt `config.yml` und `messages.yml` neu.

API

Mit der API liest und änderst du, wie Spieler angezeigt werden, und fügst eigene Gruppen hinzu.

Dependency hinzufügen

Auf die API zugreifen

Paper
Minestom

import app.simplecloud.prefixes.api.PrefixesApi
import org.bukkit.Bukkit

val api = Bukkit.getServicesManager().getRegistration(PrefixesApi::class.java)?.provider
    ?: throw IllegalStateException("PrefixesApi is not registered")

import app.simplecloud.prefixes.api.PrefixesApi;
import org.bukkit.Bukkit;
import org.bukkit.plugin.RegisteredServiceProvider;

RegisteredServiceProvider<PrefixesApi> registration =
    Bukkit.getServicesManager().getRegistration(PrefixesApi.class);

if (registration == null) {
    throw new IllegalStateException("PrefixesApi is not registered");
}

PrefixesApi api = registration.getProvider();

val api = PrefixesMinestom.getApi()

PrefixesApi api = PrefixesMinestom.getApi();

Auf jeder Plattform geht auch PrefixesApiProvider.get(). Läuft Prefixes nicht, wirft das eine IllegalStateException.

Spieler abfragen

Die Beispiele nutzen die api von oben und einen Player von Paper oder Minestom. Die Gruppe eines Spielers abfragen. Passt keine Gruppe, ist das Ergebnis null:

val group = api.getPrimaryGroup(player.uniqueId).await()
player.sendMessage(Component.text("Your group: ${group?.name ?: "none"}"))

api.getPrimaryGroup(player.getUniqueId()).thenAccept(group -> {
    String name = group != null ? group.getName() : "none";
    player.sendMessage(Component.text("Your group: " + name));
});

Abfragen, was gerade für einen Spieler angezeigt wird. Alle Änderungen über die API sind schon mit drin:

val data = api.getPrefixData(player.uniqueId).await()
player.sendMessage(data.prefix.append(data.displayName).append(data.suffix))

api.getPrefixData(player.getUniqueId()).thenAccept(data ->
    player.sendMessage(data.getPrefix().append(data.getDisplayName()).append(data.getSuffix())));

Methode	Wert
`getPrefix()`	Prefix
`getSuffix()`	Suffix
`getColor()`	Namensfarbe
`getDisplayName()`	Gerenderter Nametag
`getChatFormat()`	Chat-Format als MiniMessage-String
`getPriority()`	Position in der Tablist, höher steht weiter oben

Anzeige eines Spielers ändern

Ändere Prefix, Suffix, Farbe oder die Position in der Tablist eines Spielers für alle. Die Änderung gilt für Chat, Tablist und Nametag.

api.setPrefix(player.uniqueId, Component.text("[Builder] ", NamedTextColor.GOLD))
api.setColor(player.uniqueId, NamedTextColor.GOLD)

api.setPrefix(player.getUniqueId(), Component.text("[Builder] ", NamedTextColor.GOLD));
api.setColor(player.getUniqueId(), NamedTextColor.GOLD);

Beschreibung	Methode
Prefix setzen	`setPrefix(id, prefix)`
Suffix setzen	`setSuffix(id, suffix)`
Namensfarbe setzen	`setColor(id, color)`
Position in der Tablist setzen	`setPriority(id, priority)`
Spieler mit einer anderen Gruppe anzeigen	`setGroup(id, group)`
Alle Änderungen zurücksetzen	`reset(id)`

setGroup nimmt eine PrefixesGroup oder einen Gruppennamen. Gibt es keine Gruppe mit dem Namen, kommt false zurück:

val found = api.setGroup(player.uniqueId, "admin").await()
if (!found) println("The group admin does not exist")

api.setGroup(player.getUniqueId(), "admin").thenAccept(found -> {
    if (!found) System.out.println("The group admin does not exist");
});

Änderungen funktionieren nur bei Spielern, die online sind, und sind weg, sobald der Spieler den Server verlässt. Sollen sie bleiben, setz sie beim Join einfach neu.

Spieler für bestimmte Spieler anders anzeigen

Mit Per-Viewer-Änderungen sehen verschiedene Spieler denselben Spieler unterschiedlich. Das ist praktisch für alles, was von der Beziehung zwischen zwei Spielern abhängt:

Freunde: Ein Spieler sieht seine Freunde mit einem [Friend]-Prefix
Partys: Party-Mitglieder sehen sich gegenseitig mit Party-Prefix ganz oben in der Tablist
Teams: In einem Minigame sieht jedes Team die eigenen Leute grün und die Gegner rot

Jede set-Methode und setGroup haben ein optionales viewers-Argument. Nur diese Spieler sehen die Änderung, alle anderen sehen weiter den normalen Prefix. viewers ist eine Adventure-Audience, du kannst also einen Spieler übergeben oder mehrere mit Audience.audience(players). Einen Freund mit [Friend]-Prefix anzeigen, nur für den Spieler:

api.setPrefix(friend.uniqueId, Component.text("[Friend] ", NamedTextColor.GREEN), player)

api.setPrefix(friend.getUniqueId(), Component.text("[Friend] ", NamedTextColor.GREEN), player);

Party-Mitglieder mit [Party]-Prefix ganz oben in der Tablist anzeigen, nur für die Party:

val party = Audience.audience(partyMembers)

partyMembers.forEach { member ->
    api.setPrefix(member.uniqueId, Component.text("[Party] ", NamedTextColor.LIGHT_PURPLE), party)
    api.setPriority(member.uniqueId, 1000, party)
}

Audience party = Audience.audience(partyMembers);

for (Player member : partyMembers) {
    api.setPrefix(member.getUniqueId(), Component.text("[Party] ", NamedTextColor.LIGHT_PURPLE), party);
    api.setPriority(member.getUniqueId(), 1000, party);
}

setGroup geht auch für mehrere Spieler auf einmal. In einem Minigame sieht so jedes Team die eigenen Leute mit der einen Gruppe und das andere Team mit einer anderen:

val red = Audience.audience(redTeam)
val blue = Audience.audience(blueTeam)

api.setGroup(red, "teammate", red)
api.setGroup(red, "enemy", blue)
api.setGroup(blue, "teammate", blue)
api.setGroup(blue, "enemy", red)

Audience red = Audience.audience(redTeam);
Audience blue = Audience.audience(blueTeam);

api.setGroup(red, "teammate", red);
api.setGroup(red, "enemy", blue);
api.setGroup(blue, "teammate", blue);
api.setGroup(blue, "enemy", red);

Die Gruppen teammate und enemy müssen in deiner Gruppenquelle existieren. Mit reset(targets, viewers) entfernst du nur die Änderungen, die bestimmte Spieler sehen, zum Beispiel wenn eine Freundschaft endet oder jemand die Party verlässt:

// Der Spieler sieht den [Friend]-Prefix nicht mehr
api.reset(friend, player)

// Die Party sieht den Spieler nicht mehr als Mitglied und umgekehrt
api.reset(player, party)
api.reset(party, player)

// Der Spieler sieht den [Friend]-Prefix nicht mehr
api.reset(friend, player);

// Die Party sieht den Spieler nicht mehr als Mitglied und umgekehrt
api.reset(player, party);
api.reset(party, player);

Was ein bestimmter Spieler sieht, bekommst du, wenn du ihn als Viewer übergibst: api.getPrefixData(friend.uniqueId, player). Greifen mehrere Änderungen, gewinnt die für einen bestimmten Viewer vor der für alle, und die wiederum vor der Gruppe des Spielers. Per-Viewer-Änderungen sind weg, sobald einer der beiden Spieler den Server verlässt.

Gruppen auflisten und hinzufügen

Alle Gruppen der aktuellen Gruppenquelle auflisten, höchste Priorität zuerst:

api.getGroups().await().forEach { group ->
    println("${group.priority} - ${group.name}")
}

api.getGroups().thenAccept(groups ->
    groups.forEach(group -> System.out.println(group.getPriority() + " - " + group.getName())));

Mit addGroup fügst du eine Gruppe hinzu. Bei config wird sie in der config.yml gespeichert, bei luckperms in LuckPerms angelegt. Gibt es schon eine Gruppe mit dem Namen, kommt false zurück.

val created = api.addGroup(VipGroup()).await()
if (!created) println("A group named vip already exists")

api.addGroup(new VipGroup()).thenAccept(created -> {
    if (!created) System.out.println("A group named vip already exists");
});

Spieler bekommen eine neue Gruppe wie jede andere auch, bei config also zum Beispiel über ihre permission. Eine Gruppe implementiert PrefixesGroup:

Beispiel: VipGroup

import app.simplecloud.prefixes.api.group.PrefixesGroup
import net.kyori.adventure.text.Component
import net.kyori.adventure.text.format.TextColor
import net.kyori.adventure.text.minimessage.MiniMessage
import java.util.UUID
import java.util.concurrent.CompletableFuture

class VipGroup : PrefixesGroup {
    override val name = "vip"
    override val priority = 50
    override val permission = "simplecloud.prefix.group.vip"
    override val prefix = MiniMessage.miniMessage().deserialize("<#A3E635>VIP <#475569>| ")
    override val suffix = Component.empty()
    override val color = TextColor.color(0xA3E635)
    override val displayName = "<color><playername>"
    override val chatFormat = "<prefix><color><playername><suffix> <#475569>» <#F8FAFC><message>"

    // Wird nur genutzt, wenn die Gruppe zu einem eigenen Group Provider gehört
    override fun containsPlayer(id: UUID): CompletableFuture<Boolean> =
        CompletableFuture.completedFuture(false)
}

import app.simplecloud.prefixes.api.group.PrefixesGroup;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.TextColor;
import net.kyori.adventure.text.minimessage.MiniMessage;

import java.util.UUID;
import java.util.concurrent.CompletableFuture;

public final class VipGroup implements PrefixesGroup {

    @Override
    public String getName() {
        return "vip";
    }

    @Override
    public int getPriority() {
        return 50;
    }

    @Override
    public String getPermission() {
        return "simplecloud.prefix.group.vip";
    }

    @Override
    public Component getPrefix() {
        return MiniMessage.miniMessage().deserialize("<#A3E635>VIP <#475569>| ");
    }

    @Override
    public Component getSuffix() {
        return Component.empty();
    }

    @Override
    public TextColor getColor() {
        return TextColor.color(0xA3E635);
    }

    @Override
    public String getDisplayName() {
        return "<color><playername>";
    }

    @Override
    public String getChatFormat() {
        return "<prefix><color><playername><suffix> <#475569>» <#F8FAFC><message>";
    }

    // Wird nur genutzt, wenn die Gruppe zu einem eigenen Group Provider gehört
    @Override
    public CompletableFuture<Boolean> containsPlayer(UUID id) {
        return CompletableFuture.completedFuture(false);
    }
}

Eigenen Group Provider erstellen

Ein Group Provider legt fest, welche Gruppen es gibt und in welcher Gruppe ein Spieler ist. Prefixes bringt die Provider config und luckperms mit. Mit einem eigenen Provider kommen die Gruppen direkt aus deinem Plugin, zum Beispiel aus deinem eigenen Rangsystem. Implementiere dafür GroupProvider. Dieses Beispiel hält die Gruppen und das Team jedes Spielers im Speicher:

import app.simplecloud.prefixes.api.group.GroupProvider
import app.simplecloud.prefixes.api.group.PrefixesGroup
import java.util.UUID
import java.util.concurrent.CompletableFuture
import java.util.concurrent.ConcurrentHashMap

class TeamGroupProvider : GroupProvider {
    private val groups = ConcurrentHashMap<String, PrefixesGroup>()
    private val teams = ConcurrentHashMap<UUID, String>()

    fun setTeam(id: UUID, team: String) {
        teams[id] = team
    }

    // Name für general.source
    override fun getName() = "teams"

    override fun getGroups(): CompletableFuture<Collection<PrefixesGroup>> =
        CompletableFuture.completedFuture(groups.values.sortedByDescending { it.priority })

    override fun getGroup(id: UUID): CompletableFuture<PrefixesGroup?> {
        val team = teams[id] ?: return CompletableFuture.completedFuture(null)
        return CompletableFuture.completedFuture(groups[team])
    }

    override fun addGroup(group: PrefixesGroup): CompletableFuture<Boolean> =
        CompletableFuture.completedFuture(groups.putIfAbsent(group.name, group) == null)
}

import app.simplecloud.prefixes.api.group.GroupProvider;
import app.simplecloud.prefixes.api.group.PrefixesGroup;

import java.util.Collection;
import java.util.Comparator;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;

public final class TeamGroupProvider implements GroupProvider {
    private final Map<String, PrefixesGroup> groups = new ConcurrentHashMap<>();
    private final Map<UUID, String> teams = new ConcurrentHashMap<>();

    public void setTeam(UUID id, String team) {
        teams.put(id, team);
    }

    // Name für general.source
    @Override
    public String getName() {
        return "teams";
    }

    @Override
    public CompletableFuture<Collection<PrefixesGroup>> getGroups() {
        return CompletableFuture.completedFuture(groups.values().stream()
            .sorted(Comparator.comparingInt(PrefixesGroup::getPriority).reversed())
            .toList());
    }

    @Override
    public CompletableFuture<PrefixesGroup> getGroup(UUID id) {
        String team = teams.get(id);
        return CompletableFuture.completedFuture(team == null ? null : groups.get(team));
    }

    @Override
    public CompletableFuture<Boolean> addGroup(PrefixesGroup group) {
        return CompletableFuture.completedFuture(groups.putIfAbsent(group.getName(), group) == null);
    }
}

Registriere den Provider und trag seinen Namen in der config.yml bei general.source ein:

config.yml

general:
  source: teams

val teams = TeamGroupProvider()
api.registerGroupProvider(teams)

// Spieler, die schon online sind, bekommen ihre Gruppe vom neuen Provider
api.refreshAll()

TeamGroupProvider teams = new TeamGroupProvider();
api.registerGroupProvider(teams);

// Spieler, die schon online sind, bekommen ihre Gruppe vom neuen Provider
api.refreshAll();

Prefixes bekommt nicht mit, wenn dein Plugin die Gruppe eines Spielers ändert. Ruf danach refreshPlayer auf, damit die neue Gruppe angezeigt wird. Änderungen über die API bleiben dabei erhalten.

teams.setTeam(player.uniqueId, "red")
api.refreshPlayer(player.uniqueId)

teams.setTeam(player.getUniqueId(), "red");
api.refreshPlayer(player.getUniqueId());

Wie die eingebauten Provider umgesetzt sind, inklusive LuckPerms, siehst du auf GitHub.

Best Practices

Vergib jede Priorität nur einmal, damit die Reihenfolge in der Tablist klar ist
Nutz für alle Gruppen dasselbe chat-format, außer ein Rang soll im Chat bewusst auffallen
Nutz <color> in display-name und chat-format, statt Hex-Codes zu wiederholen
Lass default-group auf eine Gruppe mit leerer permission zeigen, damit jeder Spieler eine Gruppe hat
Nutz das viewers-Argument für Freunde, Partys und Teams, statt für jedes eine eigene Gruppe anzulegen

Introduction

Setup

Configuration

Plugins

Unterstützte Software

Plugin installieren

Konfiguration

config.yml

Gruppenquellen

Platzhalter

Features

Netzwerk-Sync

Befehle

API

Dependency hinzufügen

Auf die API zugreifen

Spieler abfragen

Anzeige eines Spielers ändern

Spieler für bestimmte Spieler anders anzeigen

Gruppen auflisten und hinzufügen

Eigenen Group Provider erstellen

Best Practices

​Unterstützte Software

​Plugin installieren

​Konfiguration

​config.yml

​Gruppenquellen

​Platzhalter

​Features

​Netzwerk-Sync

​Befehle

​API

​Dependency hinzufügen

​Auf die API zugreifen

​Spieler abfragen

​Anzeige eines Spielers ändern

​Spieler für bestimmte Spieler anders anzeigen

​Gruppen auflisten und hinzufügen

​Eigenen Group Provider erstellen

​Best Practices

Unterstützte Software

Plugin installieren

Konfiguration

config.yml

Gruppenquellen

Platzhalter

Features

Netzwerk-Sync

Befehle

API

Dependency hinzufügen

Auf die API zugreifen

Spieler abfragen

Anzeige eines Spielers ändern

Spieler für bestimmte Spieler anders anzeigen

Gruppen auflisten und hinzufügen

Eigenen Group Provider erstellen

Best Practices