feat: configurable broadcasts + /core reload
New fr.luc.crcore.broadcast module: - BroadcastAudience enum (NONE, LEADER, TEAM, ADMIN, ALL). - BroadcastContext (fluent: team + involvedPlayerId + placeholders). - BroadcastService interface + YamlBroadcastService impl. - CRCoreBroadcastListener (Bukkit listener) wires the 12 native events (9 team + 3 player) to broadcasts.broadcast(eventKey, ctx). Same single-per-plugin file pattern as messages: <plugin-dataFolder>/<plugin-name-lowercase>-broadcasts.yml. Defaults bundled at resources/crcore-broadcasts.yml, copied on first boot (game plugin's own resource of the same name takes priority as the template). In-memory fallback so new CR-Core keys work without admin edit. Routes (who) vs templates (what) are separated: broadcasts.yml lists audiences per eventKey, messages.yml contains the templates under keys <eventKey>.broadcast. Admin can change either independently. 12 new *.broadcast keys added to crcore-messages.yml with sensible French defaults and color codes. Listener injects standard placeholders (name, team_name, tag, color, visibility, player, new_leader, old/new_value, etc.). ADMIN audience resolved via crcore.broadcast.admin permission. Multi- audiences via YAML list (e.g., [TEAM, ADMIN]); union of resolved players, no duplicate. New /core reload subcommand (permission crcore.reload) hot-reloads both messages and broadcasts from disk without restart. CRCore: protected buildBroadcastService() override point, getter broadcasts(), wire of CRCoreBroadcastListener at enable(). CoreCommand constructor extended to take BroadcastService, registers the reload subcommand. Docs/features.md: new section 9 "Service de broadcasts". docs/setup.md: updated to mention both YAML files. decisions.md logs the routes-vs- templates split, the audience model, and the reload semantics. New diagram broadcasts-class-diagram.puml. README updated. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
Antone Barbaud
@@ -30,6 +30,12 @@ d'initialisation côté plugin de jeu :
|
||||
YAML `<plugin>-messages.yml` dans le dataFolder du plugin de jeu,
|
||||
avec defaults CR-Core en fallback. L'admin édite un seul fichier,
|
||||
placeholders nommés, codes couleur `&` natifs.
|
||||
- **Broadcasts configurables** — `BroadcastService` route chaque event
|
||||
CR-Core vers une liste d'audiences (`NONE`, `LEADER`, `TEAM`, `ADMIN`,
|
||||
`ALL`) définie dans `<plugin>-broadcasts.yml`. Séparation routes /
|
||||
templates. Un listener interne wire les 12 events natifs ; les game
|
||||
plugins peuvent broadcast leurs propres events. `/core reload` recharge
|
||||
les deux fichiers à chaud.
|
||||
- **Bootstrap unique** — `new CRCore(this).enable()` dans le `onEnable()`
|
||||
du plugin de jeu, et tout est branché.
|
||||
|
||||
@@ -55,6 +61,7 @@ d'initialisation côté plugin de jeu :
|
||||
| [events-diagram.puml](diagrams/events-diagram.puml) | Classe | Évènements Bukkit team + player |
|
||||
| [database-diagram.puml](diagrams/database-diagram.puml) | Classe | Wrapper SQLite + table builder |
|
||||
| [messages-class-diagram.puml](diagrams/messages-class-diagram.puml) | Classe | Service de messages YAML |
|
||||
| [broadcasts-class-diagram.puml](diagrams/broadcasts-class-diagram.puml) | Classe | Service de broadcasts YAML + listener |
|
||||
| [bootstrap-sequence.puml](diagrams/bootstrap-sequence.puml) | Séquence | `CRCore.enable()` côté plugin de jeu |
|
||||
|
||||
## Conventions
|
||||
|
||||
@@ -367,6 +367,42 @@ Format léger : une décision = un titre + contexte + choix + raison.
|
||||
bases existantes, ALTER TABLE manuel ou suppression du fichier
|
||||
(les bases d'event sont jetables).
|
||||
|
||||
## 2026-06-10 — Système de broadcasts configurables + `/core reload`
|
||||
|
||||
- **Choix** : nouveau module `fr.luc.crcore.broadcast` avec
|
||||
`BroadcastService` + `BroadcastAudience` enum + `BroadcastContext` data
|
||||
class + `YamlBroadcastService` impl. Un listener Bukkit interne
|
||||
(`CRCoreBroadcastListener`) écoute les 12 events CR-Core et les traduit
|
||||
en appels `broadcast(eventKey, ctx)`.
|
||||
- **Modèle « un seul fichier par plugin »** identique à messages :
|
||||
`<plugin-dataFolder>/<plugin-name-lowercase>-broadcasts.yml`. Defaults
|
||||
bundlés dans le jar à `crcore-broadcasts.yml`, copiés au premier boot
|
||||
(avec priorité au template du plugin de jeu sous le même nom s'il en
|
||||
fournit un).
|
||||
- **Séparation routes / templates** :
|
||||
- **Routes** = qui reçoit quoi = `<plugin>-broadcasts.yml` (liste
|
||||
d'audiences par event)
|
||||
- **Templates** = quel texte = `<plugin>-messages.yml` (clés
|
||||
`<eventKey>.broadcast`)
|
||||
- L'admin peut modifier l'un sans toucher à l'autre. Modulaire.
|
||||
- **5 audiences** : `NONE`, `LEADER`, `TEAM`, `ADMIN`, `ALL`.
|
||||
Multi-cibles via liste, union sans doublon.
|
||||
- **Permission ADMIN** : `crcore.broadcast.admin` (granular,
|
||||
configurable côté LuckPerms).
|
||||
- **Listener Bukkit interne** : `CRCoreBroadcastListener` est instancié
|
||||
et enregistré dans `CRCore.enable()`. Les game plugins n'ont rien à
|
||||
faire pour bénéficier du broadcast des events natifs CR-Core ; pour
|
||||
leurs propres events, ils appellent `core.broadcasts().broadcast(...)`.
|
||||
- **Pas de cancellation** : le broadcast est post-event ; si une route
|
||||
est mal configurée, on ne casse pas la logique métier — au pire un
|
||||
message non envoyé ou envoyé trop large.
|
||||
- **Nouvelle commande `/core reload`** : permission `crcore.reload`,
|
||||
recharge `messages` + `broadcasts` depuis les fichiers user. Les
|
||||
defaults en jar restent fixes. Hot reload utile en dev / pour ajuster
|
||||
les routes sans restart.
|
||||
- **Override de l'impl** : `CRCore.buildBroadcastService(messages)` est
|
||||
`protected` — comme pour les autres services.
|
||||
|
||||
## 2026-06-09 — Réorganisation packages : `impl/` et `exception/` séparés
|
||||
|
||||
- **Choix** : pour chaque domaine (`team`, `player`, `message`), les
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
@startuml broadcasts-class-diagram
|
||||
title CR-Core — Broadcast service (class diagram)
|
||||
|
||||
skinparam classAttributeIconSize 0
|
||||
hide empty members
|
||||
|
||||
package "fr.luc.crcore.broadcast" {
|
||||
|
||||
enum BroadcastAudience {
|
||||
NONE
|
||||
LEADER
|
||||
TEAM
|
||||
ADMIN
|
||||
ALL
|
||||
}
|
||||
|
||||
class BroadcastContext {
|
||||
- team: Team
|
||||
- involvedPlayerId: UUID
|
||||
- placeholders: Map<String, String>
|
||||
--
|
||||
+ {static} of(team): BroadcastContext
|
||||
+ {static} empty(): BroadcastContext
|
||||
+ involving(playerId): BroadcastContext
|
||||
+ with(key, value): BroadcastContext
|
||||
+ getTeam(): Optional<Team>
|
||||
+ getInvolvedPlayerId(): Optional<UUID>
|
||||
+ getPlaceholders(): Map<String, String>
|
||||
+ toPlaceholderPairs(): Object[]
|
||||
}
|
||||
|
||||
interface BroadcastService {
|
||||
+ broadcast(eventKey, context): void
|
||||
+ getAudiences(eventKey): List<BroadcastAudience>
|
||||
+ reload(): void
|
||||
}
|
||||
|
||||
class CRCoreBroadcastListener {
|
||||
- broadcasts: BroadcastService
|
||||
+ registerOn(plugin: JavaPlugin): void
|
||||
--
|
||||
@ onTeamCreate(TeamCreateEvent)
|
||||
@ onTeamDissolve(TeamDissolveEvent)
|
||||
@ onTeamMemberAdd(TeamMemberAddEvent)
|
||||
@ onTeamMemberRemove(TeamMemberRemoveEvent)
|
||||
@ onPlayerJoinTeam(PlayerJoinTeamEvent)
|
||||
@ onLeadershipTransfer(TeamLeadershipTransferEvent)
|
||||
@ onVisibilityChange(TeamVisibilityChangeEvent)
|
||||
@ onTeamScoreChange(TeamScoreChangeEvent)
|
||||
@ onTeamSpawnChange(TeamSpawnPointChangeEvent)
|
||||
@ onProfileCreate(PlayerProfileCreateEvent)
|
||||
@ onProfileDelete(PlayerProfileDeleteEvent)
|
||||
@ onPlayerScoreChange(PlayerScoreChangeEvent)
|
||||
}
|
||||
CRCoreBroadcastListener ..|> "org.bukkit.event.Listener"
|
||||
|
||||
package "fr.luc.crcore.broadcast.impl" {
|
||||
class YamlBroadcastService {
|
||||
- plugin: JavaPlugin
|
||||
- messages: MessagesService
|
||||
- defaults: Map<String, List<BroadcastAudience>>
|
||||
- audiences: Map<String, List<BroadcastAudience>>
|
||||
- userFile: File
|
||||
--
|
||||
+ YamlBroadcastService(plugin, messages)
|
||||
- loadDefaultsFromResource(): void
|
||||
- ensureUserFile(): void
|
||||
- rebuildEffectiveAudiences(): void
|
||||
- resolveRecipients(list, ctx): Set<Player>
|
||||
}
|
||||
YamlBroadcastService ..|> BroadcastService
|
||||
}
|
||||
|
||||
BroadcastService ..> BroadcastContext : consumes
|
||||
BroadcastContext --> BroadcastAudience
|
||||
YamlBroadcastService --> "fr.luc.crcore.message.MessagesService" : reads templates
|
||||
CRCoreBroadcastListener --> BroadcastService : delegates
|
||||
CRCoreBroadcastListener ..> BroadcastContext : builds
|
||||
}
|
||||
|
||||
package "fr.luc.crcore" {
|
||||
class CRCore {
|
||||
+ broadcasts(): BroadcastService
|
||||
# buildBroadcastService(messages): BroadcastService
|
||||
}
|
||||
CRCore "1" *-- "1" BroadcastService : owns
|
||||
CRCore ..> CRCoreBroadcastListener : registers
|
||||
}
|
||||
|
||||
note bottom of YamlBroadcastService
|
||||
Modèle "un seul fichier par plugin" :
|
||||
|
||||
Sources en mémoire :
|
||||
1. crcore-broadcasts.yml ← jar (fallback)
|
||||
2. <plugin>-broadcasts.yml ← dataFolder (édité par l'admin)
|
||||
|
||||
Séparation routes / templates :
|
||||
- Routes = ce fichier (qui reçoit quoi)
|
||||
- Templates = MessagesService (clés <event>.broadcast)
|
||||
end note
|
||||
|
||||
@enduml
|
||||
+124
-1
@@ -684,7 +684,130 @@ placeholders documentés en commentaire.
|
||||
|
||||
---
|
||||
|
||||
## 9. Bootstrap `CRCore`
|
||||
## 9. Service de broadcasts (`fr.luc.crcore.broadcast`)
|
||||
|
||||
**Statut** : implémenté. Un seul listener Bukkit interne route les 12
|
||||
événements CR-Core vers le {@code BroadcastService} qui décide à qui
|
||||
envoyer le message selon la config YAML.
|
||||
|
||||
### Séparation routes / templates
|
||||
|
||||
- **Routes** (« qui reçoit quoi ») → `<plugin>-broadcasts.yml`
|
||||
- **Templates** (« quel texte ») → `<plugin>-messages.yml`, clés
|
||||
`<eventKey>.broadcast` (ex. `team.create.broadcast`)
|
||||
|
||||
Les deux fichiers sont modifiables indépendamment. L'admin peut couper
|
||||
tous les broadcasts en passant tout en `[NONE]` sans toucher aux templates,
|
||||
ou inversement changer la formulation sans toucher aux routes.
|
||||
|
||||
### `BroadcastAudience` — qui reçoit
|
||||
|
||||
| Audience | Résolution |
|
||||
|---|---|
|
||||
| `NONE` | Personne (équivalent à liste vide). |
|
||||
| `LEADER` | Le chef de l'équipe concernée (s'il est en ligne). |
|
||||
| `TEAM` | Tous les membres en ligne de l'équipe concernée. |
|
||||
| `ADMIN` | Joueurs en ligne ayant la perm `crcore.broadcast.admin`. |
|
||||
| `ALL` | Tous les joueurs en ligne sur le serveur. |
|
||||
|
||||
Multi-cibles : une clé d'event mappe sur une **liste** d'audiences. Union
|
||||
(pas de doublon : un joueur dans deux audiences reçoit un seul message).
|
||||
|
||||
### Le fichier `<plugin>-broadcasts.yml` — exemple
|
||||
|
||||
```yaml
|
||||
team:
|
||||
create: [ADMIN] # admins voient les créations
|
||||
dissolve: [TEAM, ADMIN]
|
||||
member:
|
||||
add: [TEAM]
|
||||
remove: [TEAM]
|
||||
player:
|
||||
join: [TEAM]
|
||||
leadership:
|
||||
transfer: [TEAM, ADMIN]
|
||||
visibility:
|
||||
change: [LEADER]
|
||||
score:
|
||||
change: [NONE] # noisy par défaut
|
||||
spawn:
|
||||
change: [LEADER]
|
||||
|
||||
player:
|
||||
profile:
|
||||
create: [NONE]
|
||||
delete: [ADMIN]
|
||||
score:
|
||||
change: [NONE]
|
||||
```
|
||||
|
||||
### Liste des `eventKey` (= mapping listener)
|
||||
|
||||
| Bukkit event | Clé broadcasts.yml | Clé messages.yml |
|
||||
|---|---|---|
|
||||
| `TeamCreateEvent` | `team.create` | `team.create.broadcast` |
|
||||
| `TeamDissolveEvent` | `team.dissolve` | `team.dissolve.broadcast` |
|
||||
| `TeamMemberAddEvent` | `team.member.add` | `team.member.add.broadcast` |
|
||||
| `TeamMemberRemoveEvent` | `team.member.remove` | `team.member.remove.broadcast` |
|
||||
| `PlayerJoinTeamEvent` | `team.player.join` | `team.player.join.broadcast` |
|
||||
| `TeamLeadershipTransferEvent` | `team.leadership.transfer` | `team.leadership.transfer.broadcast` |
|
||||
| `TeamVisibilityChangeEvent` | `team.visibility.change` | `team.visibility.change.broadcast` |
|
||||
| `TeamScoreChangeEvent` | `team.score.change` | `team.score.change.broadcast` |
|
||||
| `TeamSpawnPointChangeEvent` | `team.spawn.change` | `team.spawn.change.broadcast` |
|
||||
| `PlayerProfileCreateEvent` | `player.profile.create` | `player.profile.create.broadcast` |
|
||||
| `PlayerProfileDeleteEvent` | `player.profile.delete` | `player.profile.delete.broadcast` |
|
||||
| `PlayerScoreChangeEvent` | `player.score.change` | `player.score.change.broadcast` |
|
||||
|
||||
### Placeholders injectés par le listener
|
||||
|
||||
Pour les events team, le contexte inclut toujours : `{name}`, `{team_name}`
|
||||
(alias), `{tag}`, `{color}` (code couleur ChatColor), `{visibility}`.
|
||||
Quand pertinent, en plus : `{player}` (nom du joueur impliqué),
|
||||
`{new_leader}`, `{old_leader}`, `{old_visibility}`, `{new_visibility}`,
|
||||
`{score_name}`, `{old_value}`, `{new_value}`, `{delta}`.
|
||||
|
||||
### API pour les game plugins
|
||||
|
||||
```java
|
||||
// Broadcast custom depuis un game plugin
|
||||
core.broadcasts().broadcast("mygame.round.start",
|
||||
BroadcastContext.empty()
|
||||
.with("round", String.valueOf(currentRound))
|
||||
.with("map", mapName));
|
||||
|
||||
// Lecture des audiences configurées (debug)
|
||||
List<BroadcastAudience> who = core.broadcasts().getAudiences("team.create");
|
||||
|
||||
// Hot reload
|
||||
core.broadcasts().reload();
|
||||
```
|
||||
|
||||
Pour ajouter ses propres events broadcast, le game plugin :
|
||||
1. Ajoute la clé dans son `<plugin>-broadcasts.yml` (ex.
|
||||
`mygame.round.start: [ALL]`)
|
||||
2. Ajoute le template dans `<plugin>-messages.yml` (clé
|
||||
`mygame.round.start.broadcast`)
|
||||
3. Appelle `core.broadcasts().broadcast(...)` quand l'event survient
|
||||
|
||||
### Override de l'impl
|
||||
|
||||
`CRCore.buildBroadcastService(messages)` est `protected`. Sous-classe
|
||||
{@code CRCore} pour fournir une impl alternative (base de données, queue
|
||||
externe, etc.).
|
||||
|
||||
### Commande `/core reload`
|
||||
|
||||
Permission : `crcore.reload`. Recharge à la fois `messages` et `broadcasts`
|
||||
depuis les fichiers user du dataFolder. Les defaults en jar ne bougent pas
|
||||
(pas re-chargés).
|
||||
|
||||
### Diagramme
|
||||
|
||||
- Classes : [broadcasts-class-diagram.puml](diagrams/broadcasts-class-diagram.puml)
|
||||
|
||||
---
|
||||
|
||||
## 10. Bootstrap `CRCore`
|
||||
|
||||
**Statut** : implémenté. Point d'entrée unique pour les plugins de jeu.
|
||||
|
||||
|
||||
@@ -265,6 +265,24 @@ CitesPlugin/ # dossier IntelliJ (renommer plus t
|
||||
└── SqlitePlayerProfileRepository.java
|
||||
```
|
||||
|
||||
## Fichiers de config générés au premier `enable()`
|
||||
|
||||
Au premier démarrage, CR-Core crée DEUX fichiers dans le dataFolder :
|
||||
|
||||
| Fichier | Rôle |
|
||||
|---|---|
|
||||
| `<plugin-name-lowercase>-messages.yml` | Templates de tous les messages (commandes + broadcasts) |
|
||||
| `<plugin-name-lowercase>-broadcasts.yml` | Routes : qui reçoit quel event |
|
||||
|
||||
Les deux suivent le même pattern : si ton plugin de jeu bundle un fichier
|
||||
au même nom dans ses ressources, c'est lui qui sert de template initial à
|
||||
la place des defaults CR-Core. Les defaults restent en mémoire en
|
||||
fallback — donc les clés non présentes dans le fichier user marchent quand
|
||||
même.
|
||||
|
||||
Hot reload : `/core reload` (permission `crcore.reload`) relit les deux
|
||||
fichiers sans restart.
|
||||
|
||||
## Fichier messages
|
||||
|
||||
Au premier `enable()`, CR-Core crée :
|
||||
|
||||
@@ -1,5 +1,8 @@
|
||||
package fr.luc.crcore;
|
||||
|
||||
import fr.luc.crcore.broadcast.BroadcastService;
|
||||
import fr.luc.crcore.broadcast.CRCoreBroadcastListener;
|
||||
import fr.luc.crcore.broadcast.impl.YamlBroadcastService;
|
||||
import fr.luc.crcore.command.builtin.CoreCommand;
|
||||
import fr.luc.crcore.database.Database;
|
||||
import fr.luc.crcore.message.MessagesService;
|
||||
@@ -80,6 +83,7 @@ public class CRCore {
|
||||
private PlayerProfileRepository playerProfileRepository;
|
||||
private PlayerProfileService playerProfileService;
|
||||
private MessagesService messages;
|
||||
private BroadcastService broadcasts;
|
||||
private CoreCommand coreCommand;
|
||||
private boolean enabled = false;
|
||||
|
||||
@@ -118,8 +122,12 @@ public class CRCore {
|
||||
this.playerProfileService = buildPlayerProfileService(playerProfileRepository);
|
||||
|
||||
this.messages = buildMessagesService();
|
||||
this.broadcasts = buildBroadcastService(messages);
|
||||
|
||||
this.coreCommand = buildCoreCommand(teamService, playerProfileService, messages);
|
||||
// Listener Bukkit qui route les events CR-Core vers le BroadcastService.
|
||||
new CRCoreBroadcastListener(broadcasts).registerOn(plugin);
|
||||
|
||||
this.coreCommand = buildCoreCommand(teamService, playerProfileService, messages, broadcasts);
|
||||
registerCommand();
|
||||
|
||||
registerPlaceholderHook();
|
||||
@@ -188,8 +196,9 @@ public class CRCore {
|
||||
/** Construit le {@link CoreCommand}. Override pour ajouter des groupes top-level. */
|
||||
protected CoreCommand buildCoreCommand(TeamService teamService,
|
||||
PlayerProfileService playerProfileService,
|
||||
MessagesService messages) {
|
||||
return new CoreCommand(teamService, playerProfileService, messages);
|
||||
MessagesService messages,
|
||||
BroadcastService broadcasts) {
|
||||
return new CoreCommand(teamService, playerProfileService, messages, broadcasts);
|
||||
}
|
||||
|
||||
/** Construit le {@link MessagesService}. Override pour utiliser une impl custom. */
|
||||
@@ -197,6 +206,11 @@ public class CRCore {
|
||||
return new YamlMessagesService(plugin);
|
||||
}
|
||||
|
||||
/** Construit le {@link BroadcastService}. Override pour utiliser une impl custom. */
|
||||
protected BroadcastService buildBroadcastService(MessagesService messages) {
|
||||
return new YamlBroadcastService(plugin, messages);
|
||||
}
|
||||
|
||||
/**
|
||||
* Enregistre {@link #coreCommand} sous le nom configuré, avec fallback
|
||||
* dynamique. Stratégie :
|
||||
@@ -273,6 +287,8 @@ public class CRCore {
|
||||
public PlayerProfileService getPlayerProfileService() { return playerProfileService; }
|
||||
public MessagesService getMessages() { return messages; }
|
||||
public MessagesService messages() { return messages; }
|
||||
public BroadcastService getBroadcasts() { return broadcasts; }
|
||||
public BroadcastService broadcasts() { return broadcasts; }
|
||||
public CoreCommand getCoreCommand() { return coreCommand; }
|
||||
public boolean isEnabled() { return enabled; }
|
||||
}
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package fr.luc.crcore.broadcast;
|
||||
|
||||
/**
|
||||
* Public destinataire d'un broadcast CR-Core.
|
||||
*
|
||||
* <p>Une clé d'event dans {@code <plugin>-broadcasts.yml} mappe sur une
|
||||
* <b>liste</b> d'audiences ; un joueur appartenant à plusieurs audiences ne
|
||||
* reçoit qu'un seul exemplaire (union de Sets).
|
||||
*/
|
||||
public enum BroadcastAudience {
|
||||
|
||||
/** Aucun broadcast. Équivalent à une liste vide. */
|
||||
NONE,
|
||||
|
||||
/** Le chef de l'équipe concernée par l'event, s'il est en ligne. */
|
||||
LEADER,
|
||||
|
||||
/** Tous les membres en ligne de l'équipe concernée par l'event. */
|
||||
TEAM,
|
||||
|
||||
/** Joueurs en ligne ayant la permission {@code crcore.broadcast.admin}. */
|
||||
ADMIN,
|
||||
|
||||
/** Tous les joueurs en ligne sur le serveur. */
|
||||
ALL
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package fr.luc.crcore.broadcast;
|
||||
|
||||
import fr.luc.crcore.team.Team;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Contexte d'un broadcast : team concernée (optionnelle), joueur impliqué
|
||||
* (optionnel) et placeholders pour la substitution dans le template message.
|
||||
*
|
||||
* <p>Builder fluide :
|
||||
* <pre>{@code
|
||||
* BroadcastContext.of(team)
|
||||
* .involving(player.getUniqueId())
|
||||
* .with("name", team.getName())
|
||||
* .with("tag", team.getTag());
|
||||
* }</pre>
|
||||
*
|
||||
* <p>Utilisé par {@link BroadcastService#broadcast(String, BroadcastContext)}
|
||||
* pour résoudre les audiences ({@link BroadcastAudience#LEADER},
|
||||
* {@link BroadcastAudience#TEAM}) et alimenter les placeholders du template.
|
||||
*/
|
||||
public final class BroadcastContext {
|
||||
|
||||
private final Team team;
|
||||
private UUID involvedPlayerId;
|
||||
private final Map<String, String> placeholders = new LinkedHashMap<>();
|
||||
|
||||
private BroadcastContext(Team team) {
|
||||
this.team = team;
|
||||
}
|
||||
|
||||
/** Contexte centré sur une équipe (le cas le plus courant). */
|
||||
public static BroadcastContext of(Team team) {
|
||||
return new BroadcastContext(team);
|
||||
}
|
||||
|
||||
/** Contexte sans équipe (events purement player, ex. PlayerProfileCreateEvent). */
|
||||
public static BroadcastContext empty() {
|
||||
return new BroadcastContext(null);
|
||||
}
|
||||
|
||||
/** Précise le joueur impliqué dans l'event (ajouté, retiré, qui a rejoint, etc.). */
|
||||
public BroadcastContext involving(UUID playerId) {
|
||||
this.involvedPlayerId = playerId;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Ajoute un placeholder {@code {key}} → {@code value} pour la substitution dans le template. */
|
||||
public BroadcastContext with(String key, String value) {
|
||||
if (key != null) {
|
||||
placeholders.put(key, value != null ? value : "");
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public Optional<Team> getTeam() {
|
||||
return Optional.ofNullable(team);
|
||||
}
|
||||
|
||||
public Optional<UUID> getInvolvedPlayerId() {
|
||||
return Optional.ofNullable(involvedPlayerId);
|
||||
}
|
||||
|
||||
/** Map immuable des placeholders accumulés. */
|
||||
public Map<String, String> getPlaceholders() {
|
||||
return Collections.unmodifiableMap(placeholders);
|
||||
}
|
||||
|
||||
/** Convertit les placeholders en varargs pour {@code messages.get(key, ...)}. */
|
||||
public Object[] toPlaceholderPairs() {
|
||||
Object[] pairs = new Object[placeholders.size() * 2];
|
||||
int i = 0;
|
||||
for (Map.Entry<String, String> entry : placeholders.entrySet()) {
|
||||
pairs[i++] = entry.getKey();
|
||||
pairs[i++] = entry.getValue();
|
||||
}
|
||||
return pairs;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package fr.luc.crcore.broadcast;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Service de broadcasts CR-Core : décide à qui envoyer un message pour un
|
||||
* event donné, selon une config YAML routière.
|
||||
*
|
||||
* <h2>Routes vs templates</h2>
|
||||
*
|
||||
* <p>Le service ne stocke <b>pas</b> les textes — il ne lit que la config
|
||||
* des audiences ({@link BroadcastAudience}) par event. Le texte vient du
|
||||
* {@code MessagesService} (clé {@code <eventKey>.broadcast}, par exemple
|
||||
* {@code team.create.broadcast}).
|
||||
*
|
||||
* <h2>Modèle de fichier</h2>
|
||||
*
|
||||
* <p>Un seul fichier par plugin :
|
||||
* {@code <plugin-dataFolder>/<plugin-name-lowercase>-broadcasts.yml}.
|
||||
* Defaults bundlés dans le jar à {@code crcore-broadcasts.yml}, copiés au
|
||||
* premier démarrage. Couche défaut + couche fichier user en mémoire ; le
|
||||
* fichier user écrase clé par clé.
|
||||
*
|
||||
* <h2>Audiences</h2>
|
||||
*
|
||||
* <p>Chaque event mappe sur une liste de {@link BroadcastAudience}. L'union
|
||||
* des Players résolus de chaque audience est destinataire. {@code [NONE]} ou
|
||||
* liste vide → pas de broadcast.
|
||||
*
|
||||
* <h2>Usage</h2>
|
||||
*
|
||||
* <pre>{@code
|
||||
* core.broadcasts().broadcast("team.create",
|
||||
* BroadcastContext.of(team)
|
||||
* .with("name", team.getName())
|
||||
* .with("tag", team.getTag())
|
||||
* .with("color", team.getColor().getChatColor().toString()));
|
||||
* }</pre>
|
||||
*
|
||||
* <p>Le listener interne {@code CRCoreBroadcastListener} fait ça
|
||||
* automatiquement pour les 12 events Bukkit livrés avec CR-Core. Les game
|
||||
* plugins peuvent appeler {@link #broadcast} avec leurs propres clés.
|
||||
*/
|
||||
public interface BroadcastService {
|
||||
|
||||
/**
|
||||
* Tire un broadcast pour l'event {@code eventKey}, en résolvant les
|
||||
* audiences configurées et en envoyant le template
|
||||
* {@code <eventKey>.broadcast} (via {@code MessagesService}) à chaque
|
||||
* destinataire.
|
||||
*/
|
||||
void broadcast(String eventKey, BroadcastContext context);
|
||||
|
||||
/** Liste des audiences configurées pour cet event (vide si rien défini). */
|
||||
List<BroadcastAudience> getAudiences(String eventKey);
|
||||
|
||||
/** Recharge la config depuis le disque (fichier user uniquement). */
|
||||
void reload();
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
package fr.luc.crcore.broadcast;
|
||||
|
||||
import fr.luc.crcore.player.event.PlayerProfileCreateEvent;
|
||||
import fr.luc.crcore.player.event.PlayerProfileDeleteEvent;
|
||||
import fr.luc.crcore.player.event.PlayerScoreChangeEvent;
|
||||
import fr.luc.crcore.team.Team;
|
||||
import fr.luc.crcore.team.event.PlayerJoinTeamEvent;
|
||||
import fr.luc.crcore.team.event.TeamCreateEvent;
|
||||
import fr.luc.crcore.team.event.TeamDissolveEvent;
|
||||
import fr.luc.crcore.team.event.TeamLeadershipTransferEvent;
|
||||
import fr.luc.crcore.team.event.TeamMemberAddEvent;
|
||||
import fr.luc.crcore.team.event.TeamMemberRemoveEvent;
|
||||
import fr.luc.crcore.team.event.TeamScoreChangeEvent;
|
||||
import fr.luc.crcore.team.event.TeamSpawnPointChangeEvent;
|
||||
import fr.luc.crcore.team.event.TeamVisibilityChangeEvent;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.Listener;
|
||||
import org.bukkit.plugin.java.JavaPlugin;
|
||||
|
||||
import java.util.Objects;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Listener Bukkit interne qui traduit chaque event CR-Core en appel à
|
||||
* {@link BroadcastService#broadcast}. Wire-up automatique au {@code
|
||||
* CRCore.enable()}.
|
||||
*
|
||||
* <p>Mapping {@code Event → eventKey} :
|
||||
* <table>
|
||||
* <tr><td>{@code TeamCreateEvent}</td> <td>{@code team.create}</td></tr>
|
||||
* <tr><td>{@code TeamDissolveEvent}</td> <td>{@code team.dissolve}</td></tr>
|
||||
* <tr><td>{@code TeamMemberAddEvent}</td> <td>{@code team.member.add}</td></tr>
|
||||
* <tr><td>{@code TeamMemberRemoveEvent}</td> <td>{@code team.member.remove}</td></tr>
|
||||
* <tr><td>{@code PlayerJoinTeamEvent}</td> <td>{@code team.player.join}</td></tr>
|
||||
* <tr><td>{@code TeamLeadershipTransferEvent}</td><td>{@code team.leadership.transfer}</td></tr>
|
||||
* <tr><td>{@code TeamVisibilityChangeEvent}</td> <td>{@code team.visibility.change}</td></tr>
|
||||
* <tr><td>{@code TeamScoreChangeEvent}</td> <td>{@code team.score.change}</td></tr>
|
||||
* <tr><td>{@code TeamSpawnPointChangeEvent}</td> <td>{@code team.spawn.change}</td></tr>
|
||||
* <tr><td>{@code PlayerProfileCreateEvent}</td> <td>{@code player.profile.create}</td></tr>
|
||||
* <tr><td>{@code PlayerProfileDeleteEvent}</td> <td>{@code player.profile.delete}</td></tr>
|
||||
* <tr><td>{@code PlayerScoreChangeEvent}</td> <td>{@code player.score.change}</td></tr>
|
||||
* </table>
|
||||
*
|
||||
* <p>Les placeholders standards injectés dans le contexte (à utiliser dans
|
||||
* les templates {@code <event>.broadcast} du fichier messages) :
|
||||
* <ul>
|
||||
* <li>{@code {name}}, {@code {tag}}, {@code {color}}, {@code {team_name}} —
|
||||
* attributs de l'équipe (le {@code team_name} et {@code name} sont
|
||||
* identiques, on garde les deux pour lisibilité des templates).</li>
|
||||
* <li>{@code {player}} — nom du joueur impliqué quand pertinent.</li>
|
||||
* <li>Spécifiques selon l'event : {@code {new_leader}}, {@code {old_value}},
|
||||
* {@code {new_value}}, {@code {score_name}}, {@code {new_visibility}},
|
||||
* etc.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class CRCoreBroadcastListener implements Listener {
|
||||
|
||||
private final BroadcastService broadcasts;
|
||||
|
||||
public CRCoreBroadcastListener(BroadcastService broadcasts) {
|
||||
this.broadcasts = Objects.requireNonNull(broadcasts, "broadcasts");
|
||||
}
|
||||
|
||||
/** Enregistre le listener sur le {@link org.bukkit.plugin.PluginManager} du serveur. */
|
||||
public void registerOn(JavaPlugin plugin) {
|
||||
Objects.requireNonNull(plugin, "plugin").getServer()
|
||||
.getPluginManager().registerEvents(this, plugin);
|
||||
}
|
||||
|
||||
// ---- Team events ----
|
||||
|
||||
@EventHandler
|
||||
public void onTeamCreate(TeamCreateEvent e) {
|
||||
broadcasts.broadcast("team.create", teamContext(e.getTeam()));
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onTeamDissolve(TeamDissolveEvent e) {
|
||||
broadcasts.broadcast("team.dissolve", teamContext(e.getTeam()));
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onTeamMemberAdd(TeamMemberAddEvent e) {
|
||||
BroadcastContext ctx = teamContext(e.getTeam())
|
||||
.involving(e.getMember().getPlayerId())
|
||||
.with("player", resolveName(e.getMember().getPlayerId()));
|
||||
broadcasts.broadcast("team.member.add", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onTeamMemberRemove(TeamMemberRemoveEvent e) {
|
||||
BroadcastContext ctx = teamContext(e.getTeam())
|
||||
.involving(e.getPlayerId())
|
||||
.with("player", resolveName(e.getPlayerId()));
|
||||
broadcasts.broadcast("team.member.remove", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onPlayerJoinTeam(PlayerJoinTeamEvent e) {
|
||||
BroadcastContext ctx = teamContext(e.getTeam())
|
||||
.involving(e.getMember().getPlayerId())
|
||||
.with("player", resolveName(e.getMember().getPlayerId()));
|
||||
broadcasts.broadcast("team.player.join", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onLeadershipTransfer(TeamLeadershipTransferEvent e) {
|
||||
BroadcastContext ctx = teamContext(e.getTeam())
|
||||
.involving(e.getNewLeaderId())
|
||||
.with("new_leader", resolveName(e.getNewLeaderId()))
|
||||
.with("old_leader", e.getOldLeaderId().map(this::resolveName).orElse("-"));
|
||||
broadcasts.broadcast("team.leadership.transfer", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onVisibilityChange(TeamVisibilityChangeEvent e) {
|
||||
BroadcastContext ctx = teamContext(e.getTeam())
|
||||
.with("old_visibility", e.getOldVisibility().name())
|
||||
.with("new_visibility", e.getNewVisibility().name());
|
||||
broadcasts.broadcast("team.visibility.change", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onTeamScoreChange(TeamScoreChangeEvent e) {
|
||||
BroadcastContext ctx = teamContext(e.getTeam())
|
||||
.with("score_name", e.getScoreName())
|
||||
.with("old_value", String.valueOf(e.getOldValue()))
|
||||
.with("new_value", String.valueOf(e.getNewValue()))
|
||||
.with("delta", String.valueOf(e.getDelta()));
|
||||
broadcasts.broadcast("team.score.change", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onTeamSpawnChange(TeamSpawnPointChangeEvent e) {
|
||||
broadcasts.broadcast("team.spawn.change", teamContext(e.getTeam()));
|
||||
}
|
||||
|
||||
// ---- Player events ----
|
||||
|
||||
@EventHandler
|
||||
public void onProfileCreate(PlayerProfileCreateEvent e) {
|
||||
BroadcastContext ctx = BroadcastContext.empty()
|
||||
.involving(e.getProfile().getPlayerId())
|
||||
.with("player", resolveName(e.getProfile().getPlayerId()));
|
||||
broadcasts.broadcast("player.profile.create", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onProfileDelete(PlayerProfileDeleteEvent e) {
|
||||
BroadcastContext ctx = BroadcastContext.empty()
|
||||
.involving(e.getProfile().getPlayerId())
|
||||
.with("player", resolveName(e.getProfile().getPlayerId()));
|
||||
broadcasts.broadcast("player.profile.delete", ctx);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onPlayerScoreChange(PlayerScoreChangeEvent e) {
|
||||
UUID playerId = e.getProfile().getPlayerId();
|
||||
BroadcastContext ctx = BroadcastContext.empty()
|
||||
.involving(playerId)
|
||||
.with("player", resolveName(playerId))
|
||||
.with("score_name", e.getScoreName())
|
||||
.with("old_value", String.valueOf(e.getOldValue()))
|
||||
.with("new_value", String.valueOf(e.getNewValue()))
|
||||
.with("delta", String.valueOf(e.getDelta()));
|
||||
broadcasts.broadcast("player.score.change", ctx);
|
||||
}
|
||||
|
||||
// ---- Helpers ----
|
||||
|
||||
/** Construit un contexte avec les placeholders standards d'une équipe. */
|
||||
private BroadcastContext teamContext(Team team) {
|
||||
return BroadcastContext.of(team)
|
||||
.with("name", team.getName())
|
||||
.with("team_name", team.getName())
|
||||
.with("tag", team.getTag())
|
||||
.with("color", team.getColor().getChatColor().toString())
|
||||
.with("visibility", team.getVisibility().name());
|
||||
}
|
||||
|
||||
@SuppressWarnings("deprecation")
|
||||
private String resolveName(UUID playerId) {
|
||||
if (playerId == null) return "-";
|
||||
OfflinePlayer p = Bukkit.getOfflinePlayer(playerId);
|
||||
String name = p.getName();
|
||||
return name != null ? name : playerId.toString();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,266 @@
|
||||
package fr.luc.crcore.broadcast.impl;
|
||||
|
||||
import fr.luc.crcore.broadcast.BroadcastAudience;
|
||||
import fr.luc.crcore.broadcast.BroadcastContext;
|
||||
import fr.luc.crcore.broadcast.BroadcastService;
|
||||
import fr.luc.crcore.message.MessagesService;
|
||||
import fr.luc.crcore.team.Team;
|
||||
import fr.luc.crcore.team.TeamMember;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.configuration.ConfigurationSection;
|
||||
import org.bukkit.configuration.file.YamlConfiguration;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.plugin.java.JavaPlugin;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
import java.util.Set;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
/**
|
||||
* Implémentation par défaut de {@link BroadcastService}, basée sur les YAML
|
||||
* Bukkit. Modèle "un seul fichier par plugin" (voir {@link BroadcastService}).
|
||||
*
|
||||
* <p>Architecture identique à {@code YamlMessagesService} :
|
||||
* <ol>
|
||||
* <li>Defaults bundlés chargés depuis {@code crcore-broadcasts.yml} dans
|
||||
* le jar — toujours en mémoire en fallback.</li>
|
||||
* <li>Fichier user {@code <dataFolder>/<plugin>-broadcasts.yml} créé au
|
||||
* premier boot (depuis le template du plugin de jeu s'il en bundle
|
||||
* un, sinon les defaults CR-Core).</li>
|
||||
* <li>Lecture : fichier user écrase les defaults clé par clé.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <p>La permission admin pour {@link BroadcastAudience#ADMIN} est
|
||||
* {@code crcore.broadcast.admin}.
|
||||
*/
|
||||
public class YamlBroadcastService implements BroadcastService {
|
||||
|
||||
/** Nom de la ressource bundlée (embarquée dans le jar CR-Core / shadée). */
|
||||
private static final String CRCORE_DEFAULTS_RESOURCE = "crcore-broadcasts.yml";
|
||||
|
||||
/** Permission qui détermine l'audience {@link BroadcastAudience#ADMIN}. */
|
||||
private static final String ADMIN_PERMISSION = "crcore.broadcast.admin";
|
||||
|
||||
private final JavaPlugin plugin;
|
||||
private final MessagesService messages;
|
||||
private final Logger logger;
|
||||
/** Couche défauts (immutable après load). */
|
||||
private final Map<String, List<BroadcastAudience>> defaults = new HashMap<>();
|
||||
/** Couche effective : defaults + fichier user. */
|
||||
private final Map<String, List<BroadcastAudience>> audiences = new HashMap<>();
|
||||
private final String userFileName;
|
||||
private final File userFile;
|
||||
|
||||
public YamlBroadcastService(JavaPlugin plugin, MessagesService messages) {
|
||||
this.plugin = Objects.requireNonNull(plugin, "plugin");
|
||||
this.messages = Objects.requireNonNull(messages, "messages");
|
||||
this.logger = plugin.getLogger();
|
||||
this.userFileName = plugin.getName().toLowerCase(Locale.ROOT) + "-broadcasts.yml";
|
||||
this.userFile = new File(plugin.getDataFolder(), userFileName);
|
||||
initialize();
|
||||
}
|
||||
|
||||
private void initialize() {
|
||||
loadDefaultsFromResource();
|
||||
ensureUserFile();
|
||||
rebuildEffectiveAudiences();
|
||||
}
|
||||
|
||||
private void loadDefaultsFromResource() {
|
||||
try (InputStream is = plugin.getResource(CRCORE_DEFAULTS_RESOURCE)) {
|
||||
if (is == null) {
|
||||
logger.warning("Ressource " + CRCORE_DEFAULTS_RESOURCE
|
||||
+ " introuvable dans le jar — defaults broadcasts indisponibles.");
|
||||
return;
|
||||
}
|
||||
YamlConfiguration cfg = YamlConfiguration.loadConfiguration(
|
||||
new InputStreamReader(is, StandardCharsets.UTF_8));
|
||||
flatten(cfg, "", defaults);
|
||||
} catch (IOException ex) {
|
||||
logger.log(Level.WARNING, "Échec lecture defaults broadcasts CR-Core", ex);
|
||||
}
|
||||
}
|
||||
|
||||
private void ensureUserFile() {
|
||||
if (userFile.exists()) return;
|
||||
if (!plugin.getDataFolder().exists() && !plugin.getDataFolder().mkdirs()) {
|
||||
logger.warning("Impossible de créer " + plugin.getDataFolder());
|
||||
return;
|
||||
}
|
||||
// Priorité 1 : ressource du plugin de jeu sous le même nom.
|
||||
try (InputStream pluginResource = plugin.getResource(userFileName)) {
|
||||
if (pluginResource != null) {
|
||||
copyStreamToFile(pluginResource, userFile);
|
||||
logger.info("Fichier broadcasts créé depuis le template du plugin : " + userFileName);
|
||||
return;
|
||||
}
|
||||
} catch (IOException ex) {
|
||||
logger.log(Level.WARNING, "Échec copie du template plugin", ex);
|
||||
}
|
||||
// Priorité 2 : copie des defaults CR-Core.
|
||||
try (InputStream coreResource = plugin.getResource(CRCORE_DEFAULTS_RESOURCE)) {
|
||||
if (coreResource != null) {
|
||||
copyStreamToFile(coreResource, userFile);
|
||||
logger.info("Fichier broadcasts créé depuis les defaults CR-Core : " + userFileName);
|
||||
}
|
||||
} catch (IOException ex) {
|
||||
logger.log(Level.WARNING, "Échec copie des defaults broadcasts", ex);
|
||||
}
|
||||
}
|
||||
|
||||
private static void copyStreamToFile(InputStream in, File target) throws IOException {
|
||||
try (FileOutputStream out = new FileOutputStream(target)) {
|
||||
in.transferTo(out);
|
||||
}
|
||||
}
|
||||
|
||||
/** Recompose la map effective : defaults + override du fichier user. */
|
||||
private void rebuildEffectiveAudiences() {
|
||||
audiences.clear();
|
||||
audiences.putAll(defaults);
|
||||
if (userFile.exists()) {
|
||||
try {
|
||||
YamlConfiguration cfg = YamlConfiguration.loadConfiguration(userFile);
|
||||
flatten(cfg, "", audiences);
|
||||
} catch (Exception ex) {
|
||||
logger.log(Level.WARNING, "Échec chargement " + userFile, ex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---- BroadcastService API ----
|
||||
|
||||
@Override
|
||||
public void broadcast(String eventKey, BroadcastContext context) {
|
||||
Objects.requireNonNull(eventKey, "eventKey");
|
||||
Objects.requireNonNull(context, "context");
|
||||
List<BroadcastAudience> audiencesList = getAudiences(eventKey);
|
||||
if (audiencesList.isEmpty() || audiencesList.contains(BroadcastAudience.NONE)
|
||||
&& audiencesList.size() == 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
Set<Player> recipients = resolveRecipients(audiencesList, context);
|
||||
if (recipients.isEmpty()) return;
|
||||
|
||||
String messageKey = eventKey + ".broadcast";
|
||||
if (!messages.has(messageKey)) {
|
||||
// Pas de template défini — silent (l'admin a configuré un broadcast
|
||||
// sans message associé, c'est une no-op intentionnelle).
|
||||
return;
|
||||
}
|
||||
String text = messages.get(messageKey, context.toPlaceholderPairs());
|
||||
for (Player p : recipients) {
|
||||
p.sendMessage(text);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<BroadcastAudience> getAudiences(String eventKey) {
|
||||
return audiences.getOrDefault(eventKey, Collections.emptyList());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void reload() {
|
||||
rebuildEffectiveAudiences();
|
||||
}
|
||||
|
||||
// ---- Résolution des audiences en Players ----
|
||||
|
||||
private Set<Player> resolveRecipients(List<BroadcastAudience> list, BroadcastContext context) {
|
||||
Set<Player> result = new LinkedHashSet<>();
|
||||
for (BroadcastAudience audience : list) {
|
||||
switch (audience) {
|
||||
case NONE:
|
||||
break;
|
||||
case LEADER:
|
||||
context.getTeam().flatMap(Team::getLeaderId)
|
||||
.map(Bukkit::getPlayer)
|
||||
.filter(Objects::nonNull)
|
||||
.ifPresent(result::add);
|
||||
break;
|
||||
case TEAM:
|
||||
context.getTeam().ifPresent(team -> {
|
||||
for (TeamMember m : team.getMembers()) {
|
||||
Player p = Bukkit.getPlayer(m.getPlayerId());
|
||||
if (p != null) result.add(p);
|
||||
}
|
||||
});
|
||||
break;
|
||||
case ADMIN:
|
||||
for (Player p : Bukkit.getOnlinePlayers()) {
|
||||
if (p.hasPermission(ADMIN_PERMISSION)) result.add(p);
|
||||
}
|
||||
break;
|
||||
case ALL:
|
||||
result.addAll(Bukkit.getOnlinePlayers());
|
||||
break;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// ---- Parsing du YAML : section imbriquée → map plate ----
|
||||
|
||||
/**
|
||||
* Parcourt récursivement la {@link ConfigurationSection} et pousse chaque
|
||||
* feuille (liste de strings ou string unique) en clé plate. Les valeurs
|
||||
* inconnues sont loggées et ignorées.
|
||||
*/
|
||||
private void flatten(ConfigurationSection section, String prefix,
|
||||
Map<String, List<BroadcastAudience>> out) {
|
||||
for (String key : section.getKeys(false)) {
|
||||
String fullKey = prefix.isEmpty() ? key : prefix + "." + key;
|
||||
Object value = section.get(key);
|
||||
if (value instanceof ConfigurationSection) {
|
||||
flatten((ConfigurationSection) value, fullKey, out);
|
||||
} else {
|
||||
List<BroadcastAudience> parsed = parseAudienceValue(fullKey, value);
|
||||
if (parsed != null) {
|
||||
out.put(fullKey, parsed);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private List<BroadcastAudience> parseAudienceValue(String key, Object value) {
|
||||
if (value == null) return Collections.emptyList();
|
||||
List<String> rawTokens = new ArrayList<>();
|
||||
if (value instanceof List<?>) {
|
||||
for (Object item : (List<?>) value) {
|
||||
if (item != null) rawTokens.add(item.toString());
|
||||
}
|
||||
} else {
|
||||
rawTokens.add(value.toString());
|
||||
}
|
||||
List<BroadcastAudience> result = new ArrayList<>(rawTokens.size());
|
||||
Set<BroadcastAudience> seen = new HashSet<>();
|
||||
for (String token : rawTokens) {
|
||||
String trimmed = token.trim();
|
||||
if (trimmed.isEmpty()) continue;
|
||||
try {
|
||||
BroadcastAudience aud = BroadcastAudience.valueOf(trimmed.toUpperCase(Locale.ROOT));
|
||||
if (seen.add(aud)) result.add(aud);
|
||||
} catch (IllegalArgumentException ex) {
|
||||
logger.warning("Audience inconnue '" + trimmed + "' pour la clé '" + key
|
||||
+ "' — ignorée. Valeurs valides : NONE, LEADER, TEAM, ADMIN, ALL.");
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
package fr.luc.crcore.command.builtin;
|
||||
|
||||
import fr.luc.crcore.broadcast.BroadcastService;
|
||||
import fr.luc.crcore.command.BaseCommand;
|
||||
import fr.luc.crcore.command.CommandResult;
|
||||
import fr.luc.crcore.command.builtin.team.TeamGroupSubCommand;
|
||||
@@ -11,43 +12,33 @@ import org.bukkit.command.CommandSender;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* Commande racine {@code /core}. Container des groupes par défaut.
|
||||
*
|
||||
* <p>Branchée par {@code CRCore.enable()} sur la {@code PluginCommand "core"}
|
||||
* du plugin de jeu (ou enregistrée dynamiquement via le {@code CommandMap}
|
||||
* si elle n'est pas dans le {@code plugin.yml}).
|
||||
*
|
||||
* <h2>Override</h2>
|
||||
* Pour remplacer un groupe entier :
|
||||
* <pre>{@code
|
||||
* core.getCoreCommand().replaceSubCommand("team", new MyTeamGroup(svc, msgs));
|
||||
* }</pre>
|
||||
* Pour remplacer une feuille :
|
||||
* <pre>{@code
|
||||
* core.getCoreCommand().findSubCommand("team")
|
||||
* .ifPresent(t -> t.replaceSubCommand("create", new MyCreate(svc, msgs)));
|
||||
* }</pre>
|
||||
* Commande racine {@code /core}. Container des groupes par défaut + la
|
||||
* sous-commande {@link CoreReloadSubCommand} ({@code /core reload}).
|
||||
*/
|
||||
public class CoreCommand extends BaseCommand {
|
||||
|
||||
protected final TeamService teamService;
|
||||
protected final PlayerProfileService playerProfileService;
|
||||
protected final MessagesService messages;
|
||||
protected final BroadcastService broadcasts;
|
||||
|
||||
public CoreCommand(TeamService teamService,
|
||||
PlayerProfileService playerProfileService,
|
||||
MessagesService messages) {
|
||||
MessagesService messages,
|
||||
BroadcastService broadcasts) {
|
||||
super("core");
|
||||
this.teamService = Objects.requireNonNull(teamService, "teamService");
|
||||
this.playerProfileService = Objects.requireNonNull(playerProfileService, "playerProfileService");
|
||||
this.messages = Objects.requireNonNull(messages, "messages");
|
||||
this.broadcasts = Objects.requireNonNull(broadcasts, "broadcasts");
|
||||
description("Commandes du noyau CR-Core");
|
||||
registerDefaults();
|
||||
}
|
||||
|
||||
/** Enregistre les groupes par défaut. Override pour ajouter / retirer des groupes. */
|
||||
/** Enregistre les groupes par défaut + la sous-commande reload. */
|
||||
protected void registerDefaults() {
|
||||
addSubCommand(new TeamGroupSubCommand(teamService, messages));
|
||||
addSubCommand(new CoreReloadSubCommand(messages, broadcasts));
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
package fr.luc.crcore.command.builtin;
|
||||
|
||||
import fr.luc.crcore.broadcast.BroadcastService;
|
||||
import fr.luc.crcore.command.CommandContext;
|
||||
import fr.luc.crcore.command.CommandResult;
|
||||
import fr.luc.crcore.command.SubCommand;
|
||||
import fr.luc.crcore.message.MessagesService;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* {@code /core reload} — recharge les fichiers
|
||||
* {@code <plugin>-messages.yml} et {@code <plugin>-broadcasts.yml} depuis
|
||||
* le disque, sans restart du serveur.
|
||||
*
|
||||
* <p>Permission : {@code crcore.reload}. Les defaults bundlés dans le jar
|
||||
* ne sont pas re-chargés (ils ne bougent pas pendant le runtime), seulement
|
||||
* les fichiers user en dataFolder.
|
||||
*/
|
||||
public class CoreReloadSubCommand extends SubCommand {
|
||||
|
||||
protected final MessagesService messages;
|
||||
protected final BroadcastService broadcasts;
|
||||
|
||||
public CoreReloadSubCommand(MessagesService messages, BroadcastService broadcasts) {
|
||||
super("reload");
|
||||
this.messages = Objects.requireNonNull(messages, "messages");
|
||||
this.broadcasts = Objects.requireNonNull(broadcasts, "broadcasts");
|
||||
description("Recharger les fichiers messages et broadcasts");
|
||||
permission("crcore.reload");
|
||||
}
|
||||
|
||||
@Override
|
||||
public CommandResult execute(CommandContext ctx) {
|
||||
messages.reload();
|
||||
broadcasts.reload();
|
||||
return CommandResult.success(messages.get("common.reload.success"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
# =============================================================================
|
||||
# CR-Core — broadcasts par défaut
|
||||
# -----------------------------------------------------------------------------
|
||||
# Ce fichier est embarqué dans le jar CR-Core et copié dans :
|
||||
# <plugin>/<nom-plugin>-broadcasts.yml
|
||||
# au premier démarrage. C'est CE fichier (la copie en dataFolder) que tu édites.
|
||||
#
|
||||
# Pour chaque event CR-Core, on définit la liste d'AUDIENCES qui reçoivent
|
||||
# le broadcast. Valeurs supportées :
|
||||
# NONE → rien (équivalent à [])
|
||||
# LEADER → le chef de l'équipe concernée (si en ligne)
|
||||
# TEAM → tous les membres en ligne de l'équipe concernée
|
||||
# ADMIN → joueurs en ligne avec la perm 'crcore.broadcast.admin'
|
||||
# ALL → tous les joueurs en ligne sur le serveur
|
||||
#
|
||||
# Multi-cibles : liste, ex. [TEAM, ADMIN]. Union → pas de doublon.
|
||||
#
|
||||
# Le TEXTE des broadcasts est dans le fichier messages (clé <event>.broadcast,
|
||||
# ex. team.create.broadcast). Ce fichier-ci ne contient QUE des routes.
|
||||
# =============================================================================
|
||||
|
||||
team:
|
||||
# Création d'une équipe (admin)
|
||||
create: [ADMIN]
|
||||
|
||||
# Dissolution d'une équipe (admin)
|
||||
dissolve: [TEAM, ADMIN]
|
||||
|
||||
# Ajout d'un membre par le chef ou l'admin
|
||||
member:
|
||||
add: [TEAM]
|
||||
remove: [TEAM]
|
||||
|
||||
# Le joueur a auto-rejoint une équipe PUBLIC
|
||||
player:
|
||||
join: [TEAM]
|
||||
|
||||
# Transfert / réassignation du leadership
|
||||
leadership:
|
||||
transfer: [TEAM, ADMIN]
|
||||
|
||||
# Visibilité PUBLIC/PRIVATE
|
||||
visibility:
|
||||
change: [LEADER]
|
||||
|
||||
# Changement d'un score d'équipe (peut être très noisy)
|
||||
score:
|
||||
change: [NONE]
|
||||
|
||||
# Définition / clear du point de spawn
|
||||
spawn:
|
||||
change: [LEADER]
|
||||
|
||||
player:
|
||||
profile:
|
||||
# Création du profil (en général à la 1re action de score — silent par défaut)
|
||||
create: [NONE]
|
||||
delete: [ADMIN]
|
||||
|
||||
score:
|
||||
# Changement d'un score joueur (très noisy si activé)
|
||||
change: [NONE]
|
||||
@@ -19,6 +19,8 @@ common:
|
||||
player-only: "&cSeul un joueur peut utiliser cette commande."
|
||||
failure: "&cÉchec de la commande."
|
||||
invalid-usage: "&cUsage incorrect."
|
||||
reload:
|
||||
success: "&aMessages et broadcasts rechargés."
|
||||
|
||||
team:
|
||||
# Placeholders : {name}
|
||||
@@ -109,3 +111,20 @@ team:
|
||||
header-score: "&eTop {count} ({score}) :"
|
||||
# Placeholders : {rank}, {color}, {name}, {value}
|
||||
entry: "&7 {rank}. {color}{name} &7— &f{value}"
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
# Messages de BROADCAST — envoyés aux audiences configurées dans
|
||||
# <plugin>-broadcasts.yml. Clé = <eventKey>.broadcast.
|
||||
# -----------------------------------------------------------------------------
|
||||
team.create.broadcast: "&7[CR] &fNouvelle équipe : {color}[{tag}] {name}"
|
||||
team.dissolve.broadcast: "&7[CR] &fL'équipe {color}{name}&f a été dissoute."
|
||||
team.member.add.broadcast: "&7[CR] &f{player} rejoint {color}{team_name}&f."
|
||||
team.member.remove.broadcast: "&7[CR] &f{player} quitte {color}{team_name}&f."
|
||||
team.player.join.broadcast: "&7[CR] &f{player} rejoint {color}{team_name}&f."
|
||||
team.leadership.transfer.broadcast: "&7[CR] &fNouveau chef de {color}{team_name}&f : {new_leader}."
|
||||
team.visibility.change.broadcast: "&7[CR] &fVisibilité de {color}{team_name}&f : {new_visibility}."
|
||||
team.score.change.broadcast: "&7[CR] &f{color}{team_name}&f : {score_name} {old_value} → &f{new_value}"
|
||||
team.spawn.change.broadcast: "&7[CR] &fSpawn de {color}{team_name}&f mis à jour."
|
||||
player.profile.create.broadcast: "&7[CR] &f{player} a maintenant un profil CR-Core."
|
||||
player.profile.delete.broadcast: "&7[CR] &fProfil de {player} supprimé."
|
||||
player.score.change.broadcast: "&7[CR] &f{player} : {score_name} {old_value} → &f{new_value}"
|
||||
|
||||
Reference in New Issue
Block a user