Accueil / Tutoriels / Les commandes / [Tutoriel] La commande /scoreboard

[Tutoriel] La commande /scoreboard

[Tutoriel] La commande /scoreboard
5(100%) 9 votes

Dans la suite des articles paraissant en cette période sur le site, nous allons aborder une autre commande très utilisée en map-making : la commande /scoreboard.

C’est une fonctionnalité apparue en 1.5, plus précisément en snapshot 13w04, qui à elle seule a commencé à démocratiser le map-making (et fut suivie de nouvelles avancées à chaque version : le /playsound en 1.6, le /summon en 1.7 ou encore le /execute en 1.8). Elle permet de créer des objectifs afin d’utiliser une ébauche de “variables” propres aux joueurs, ainsi que des équipes pour modifier les règles de combat.

Nous aborderons dans l’ordre :

  • Les objectifs (/scoreboard objectives)
  • Les joueurs (/scoreboard players)
  • Les équipes (/scoreboard teams)

 

Pocket Edition 0.15

Les objectifs

Avant de parler du /scoreboard players, qui composera la majeure partie de ce tutoriel, il est indispensable de parler des objectifs qui doivent être créés avant leur utilisation. Les objectifs correspondent à un nom de variable que le joueur crée pour pouvoir s’en servir ensuite en donnant des valeurs propres à chaque joueur.


Créer un objectif :

La première étape est donc d’abord de créer l’objectif avec une commande comme ci-dessous :

/scoreboard objectives add <Nom> <Type> [Nom d'affichage]

S’il est intuitif de deviner à quoi sert le champ “Nom”, il convient en revanche de donner des précisions sur les deux champs suivants.

Le “type” va en fait permettre de lier des variations du scoreboard à celles d’autres valeurs des statistiques du jeu. Un objectif de base, où seules les modifications effectuées par d’autres commandes vont avoir à intervenir, sera à créer avec le type “dummy” (qu’on pourrait traduire en français par “fictif” soit “faux” vu qu’il ne s’agit pas d’une vraie statistique de jeu, un peu comme les faux joueurs dont nous reparlerons plus bas).

A l’origine, il n’y avait que quelques autres types disponibles : deathCount pour compter les morts, playerKillCount pour compter le nombre de joueur tué, totalKillCount pour toutes les entités tuées (joueurs, montres et animaux) et health pour mesurer la vie du joueur.

Par la suite, un grand nombre d’autres types ont été ajoutés : le “stat” comportant un ensemble très vaste de sous-types (voir le détail plus bas), “xp” et “level” pour les points et niveau d’expérience du joueur, “food” pour le niveau dans la jauge de nourriture, “air” pour le niveau d’oxygène sous l’eau ou encore “armor” pour le nombre de point d’armure au total. Il convient également de signaler un type “trigger” qui sera abordé plus loin dans ce tutoriel.

Pour les plus curieux d’entre vous, voici une liste résumée par sous-types du “stat” :

Types de stat

  • CraftItem : s’incrémente quand un item est créé par une table de craft ou retiré d’un four après cuisson (exemple : “stats.craftItem.minecraft.wooden.door”)
  • UseItem : s’incrémente quand un item est “utilisé”, c’est à dire qu’il produit un effet par clic-droit, quand un outil peut perdre de la durabilité, qu’un bloc est placé, cela prend aussi en compte quelques comportement particuliers comme la consommation d’un colorant dans un craft ou la lecture d’un disque par un jukebox (exemple : “stat.useItem.minecraft.snowball”)
  • BreakItem : s’incrémente quand un objet avec de la durabilité casse (exemple : “stat.breakItem.minecraft.iron.pickaxe”)
  • MineBlock : s’incrémente quand un bloc est détruit, quel que soit comment, cependant cela ne fonctionne pas en créatif et il n’est pas possible de distinguer des variantes de blocs (exemple : “stat.mineBlock.minecraft.stone.stairs”)
  • KillEntity : s’incrémente quand une entité est tuée (exemple : “stat.killEntity.Blaze”)
  • Pickup : s’incrémente quand un item est recolté, en tenant compte du nombre d’objets recoltés dans un seul stack (exemple : “stat.pickup.minecraft.diamond”)
  • Drop : s’incrémente quand un item est droppé, toujours en tenant compte du nombre en un seul stack (exemple : “stat.drop.minecraft.apple”)
  • EntityKillBy : s’incrémente quand le joueur est tué par l’entité spécifiée (exemple : “stat.entityKilledBy.Enderman”)

Il y a également trois autres types fonctionnant sur le même schéma mais ne portant pas le nom de stat :

  • TeamKill : s’incrémente lorsque le joueur tue un membre d’un équipe, cependant l’équipe ne pouvant être spécifiée par son nom (les sous-types étant enregistrés de base dans le jeu), c’est par la couleur attribuée à l’équipe qu’elle sera reconnue, même si cela peut viser plusieurs équipes (exemple : “teamKill.red”)
  • KilledByTeam : s’incrémente lorsque le joueur est tué par un membre d’une équipe, toujours spécifiée comme plus haut (exemple : “killedByTeam.green”)


Une fois votre objectif créé, vous pourrez le modifier grâce aux différentes commandes du /scoreboard players, et vérifier sa valeur grâce à des sélecteurs d’entités qui sont : “score_X_min=” pour définir un minimum et “score_X=” pour définir un maximum (ici mon objectif s’appellerait ‘X’). Si vous voulez plus de détails sur l’utilisation de ces sélecteurs et sur les autres sélecteurs en général, vous pouvez vous référer à l’introduction au map-making.


Afficher un objectif :

Vous pouvez également afficher les valeurs d’un objectif aux joueurs dans un nombre limité de champs disponibles : la sidebar qui correspond à une liste sur le côté de l’écran en listant les scores les plus hauts sous le nom d’objectif (très souvent utilisée sur des serveurs pour afficher vos statistiques personnelles ou les informations sur les parties en cours), le list qui apparait quand vous appuyez sur “tab” à côté des noms de joueurs, et enfin le belowName apparaissant sous le nom du joueur dans le monde.

Un objectif peut apparaitre dans plusieurs champs à la fois, mais un seul objectif peut être affiché par champ. Il a également été ajouté un autre type de setdisplay : le sidebar team. L’affichage sera ici toujours en sidebar, mais ne sera visible qu’à certaines équipes, désignées (comme plus haut avec le TeamKill et KillByTeam) par une couleur spécifiée par “.team.couleur” (exemple : “sidebar.team.red” montrera la sidebar à toutes les équipes dont le paramètre “color” est “red”, nous verrons comment le modifier dans la dernière partie du tutoriel).

Pour mettre un objectif dans un champ il suffit d’utiliser la commande suivante :

/scoreboard objectives setdisplay <sidebar|list|belowName> [Objectif]

Pour retirer un score d’un champ, il suffit de laisser le paramètre “Objectif” vide.

Avant de passer à la section suivante, nous allons aborder un dernier point qui a déjà été cité deux fois sans être développé : le nom d’affichage. En effet, si le nom d’objectif déjà cité est utilisé par les commandes, il est possible de donner un second nom différent qui sera utilisé lors de l’affichage de l’objectif aux joueurs. Quelle utilité à ceci ? Et bien il sera possible d’inclure dans ce nom des caractères de formatage (inutilisables dans les commandes) afin de donner un meilleur visuel. Malgré cela, vous utiliserez toujours le nom principal dans les commandes. L’avantage du nom d’affichage, c’est que vous pouvez utiliser des espaces dedans pour avoir quelque chose de lisible quand il est affiché dans la sidebar.

Pour donner un nom d’affichage, il vous suffit de le spécifier dans le champ déjà abordé à l’ajout d’objectif. En revanche, pour ajouter du formatage, il vous faudra cependant utiliser un programme externe comme NBT explorer afin d’ouvrir le fichier “scoreboard” se trouvant dans le sous-dossier “data“. Dans l’ensemble “Objectives“, vous pourrez alors trouver une liste de tous vos objectifs. Pour chaque objectif, le champ “DisplayName” correspond au nom d’affichage que vous pouvez modifier.

Les formatages disponibles sont les suivants :

Formatages

Les couleurs : §0 noir, §1 bleu foncé, §2 vert foncé, §3 turquoise foncé, §4 rouge foncé, §5 violet foncé, §6 or, §7 gris, §8 gris foncé, §9 bleu, §a vert, §b turquoise, §c rouge, §d violet, §e jaune, §f blanc

Les mises en forme : §l gras, §m barré, §n souligné, §o italique

Les spéciaux : §r (reset) annule tout formatage précédent (il met fin à la chaîne formatée précédemment pour revenir au texte du base qui peut également être formaté différemment) et §k (obfusqué) fait changer les caractères très rapidement de manière aléatoire


Scoreboard DisplayName

Ici grâce au DisplayName j’aurai un nom en rouge souligné

Dernière commande utile, le “/scoreboard objectives list” vous permettra d’afficher dans le chat tous les objectifs créés sur la carte. Vous aurez les nom des objectifs, leur type ainsi que le nom d’affichage. Très pratique pour savoir si vous avez déjà créé ou non un objectif ou pour vérifier si vous ne vous êtes pas planté sur le type.

Pocket Edition 0.15

Les joueurs

Enfin nous voici dans le vif du sujet : le /scoreboard players, cette commande magique qui va nous permettre de manipuler les variables de chaque joueur, leur appliquer des opérations, tester des tags, et qui gagne de plus en plus de fonctionnalités et d’applications au fil des versions.


Introduction aux variables :

Pour commencer de façon simple, retournons en primaire pour apprendre à faire des calculs. Voici l’application la plus simple de la commande :

/scoreboard players <add|remove|set> <Joueur> <Objectif> <Valeur>

Il n’y a probablement pas besoin de détailler les arguments de la commande : set va donner une valeur choisie au score du joueur spécifié pour l’objectif précisé, tandis que add et remove vont respectivement augmenter ou diminuer le score du joueur de cette même valeur (s’il n’y a pas de score de base, l’ancienne valeur va être considérée comme 0).

Ça parait déjà simple, mais avant de passer à la suite il faut tout de même faire une petite mise en garde : la majorité de ces scores seront utilisés dans des sélecteurs, cependant de base les joueurs n’ont aucun score enregistré (ils ne partent pas de 0, mais de rien), donc il faut bien s’assurer que leur score soit “initialisé”, car un sélecteur de score ne pourra pas trouver de joueur sans valeur de score. Sachez qu’il est également possible de supprimer justement ce score, en le faisant retourner à l’état de vide, avec la commande :

/scoreboard players reset <Joueur> [Objectif]

Attention : laisser l’argument “Objectif” vide effacera tous les scores du joueur.


Cet avertissement étant donné, passons au test de ces valeurs. Si en pratique on utilise très majoritairement des sélecteurs (avec score_x_min= et score_x=), on peut être parfois amenés à utiliser un /scoreboard pour tester un score dont voici la syntaxe :

/scoreboard players test <Joueur> <Objectif> <min> [max]

Je ne pense pas avoir besoin de préciser plus le fonctionnement, donc nous évoquerons juste deux de ses principales applications. La première est tout simplement d’obtenir une réussite ou non de la commande “en permanence”, si auparavant on pouvait tester le tag SuccessCount d’un bloc de commande avec des /stats ou un simple comparateur, maintenant l’utilisation est plus simple et réactive grâce au mode “Conditionnal” des nouveaux blocs de commandes (voir l’article sur ces derniers).

La seconde application plus probable est le test du score d’un FakePlayer (Faux Joueur). Alors actuellement, un certain nombre d’entre-vous doit se demander qu’est-ce qu’un FakePlayer. Il s’agit tout simplement d’un joueur à qui on attribue un score, alors qu’il ne se trouve pas sur la map. En effet, l’argument “Joueur” peut accueillir des sélecteurs ou simplement un nom, et mettre un nom ne correspondant pas à un vrai joueur, c’est utiliser un FakePlayer.

Cela permet de stocker facilement des valeurs sans entités, mais a le défaut de rendre plus difficile les tests, car aucun sélecteur ne peut viser un FakePlayer, donc au lieu d’utiliser des sélecteurs, on utilisera le /scoreboard players test. Il est également possible de cacher le score d’un FakePlayer si l’objectif est affiché en plaçant un # au début du nom.

Tagger une entité ou un joueur

La commande /scoreboard players (…) permet aussi de marquer des entités ou des joueurs avec des tags. C’est un peu comme des scores, mais il n’y a pas besoin de créer d’objectif et on ne peut pas mettre de valeur dedans. Cela fonctionne comme ceci:

/scoreboard players <cible> tag <add|remove|list> <tag>

Ajouter un tag à une entité permet de la cibler ensuite avec un sélecteur comme celui-ci: @e[tag=marque]0


Opérations de scores :

Nous allons maintenant aborder les opérations du scoreboard. Il va être en effet possible de faire interagir ces scores entre eux, comme additionner les scores d’une même équipe, faire pour chaque joueur la différence entre deux scores, etc… Il y a au total 9 opérations réalisables grâce à la commande suivante :

/scoreboard players operation <Cible> <Objectif> <operation> <Source> <Objectif>

Avant de détailler les opérations, la syntaxe mérite cette fois-ci d’être légèrement expliquée. Il faut en effet bien faire la différence entre les joueurs spécifiés avant l’opération, et ceux étant spécifiés après. L’opération va modifier le score des joueurs spécifiés avant (précisés dans “Cible”) à partir du score des joueurs spécifiés après (précisés dans Source). Par exemple si on veut additionner les scores d’une équipe, l’entité ou le FakePlayer représentant la team sera avant, et le sélecteur visant tous ses joueurs sera après.

Ceci étant dit, voici les opérations disponibles :

  • = : le score de la cible devient celui de la source
  • += : le score de la cible s’incrémente de celui de la source
  • -= : le score de la cible se réduit de celui de la source
  • *= : le score de la cible est multiplié par celui de la source
  • /= : le score de la cible est divisé par celui de la source, si le nombre doit contenir des décimales, il est arrondie à l’unité inférieure
  • %= : le score de la cible est divisé par celui de la source, mais ici c’est le reste de cette division qui est placé dans le score de la cible (si la cible a un score de 8 et la source de 3, le score de la cible deviendra 2)
  • >< : échange le score de la source et de la cible, il s’agit de la seule opération à modifier le score de la cible
  • < : si le score de la source est inférieur à celui de la cible, celui de la cible devient celui de la source, c’est une opération un peu particulière donc je vous invite à voir l’exemple en bas
  • > : si le score de la source est supérieur à celui de la cible, celui de la cible devient celui de la source, tout comme l’opération précédente nous verrons un exemple pour l’expliquer


Applications :

Pour mieux vous faire comprendre le fonctionnement de ces opérations, nous allons donner trois exemples d’applications différentes.

Premier exemple : calculer le score total d'une équipe

Si on considère une équipe appelée “Rouge” (nom que nous donnerons à un FakePlayer) et que l’objectif utilisé est nommé “Points”, pour calculer tous les points de l’équipe, nous pouvons utiliser cette commande :

/scoreboard players operation Rouge Points += @a[team=Rouge] Points

Ainsi, en utilisant un display de type “sidebar” pour l’objectif “Points”, nous verrons une liste du score de tous les joueurs, ainsi qu’un FakePlayer nommé “Rouge” qui totalisera le score de tous les joueurs appartenant à l’équipe nommée “Rouge”.

Il est à noter qu’il faut ramener le score de “Rouge” à 0 avant d’appliquer cette opération. en effet, lorsque vous utilisez cette opération, le jeu procède de la manière suivante: “Donner à joueur Rouge son nombre de Points plus le score Points de chaque joueur de l’équipe rouge”.

Second exemple : faire un randomiseur en scoreboard

Il s’agit ici d’un des nombreux générateurs de nombre random qu’il est possible de créer. Il présente l’avantage de pouvoir centraliser toutes les randomisations à condition qu’elles ne soient pas toutes exécuter en même temps.

Nous allons utiliser ici la division avec reste %=. En utilisant un objectif nommé Random sur une entité ayant le nom custom Randomiseur, nous allons utiliser la commande suivante :

/execute @e[name=Randomiseur] ~ ~ ~ scoreboard players operation @e[name=Randomiseur,r=0] Random %= <FakePlayer> Random

(Cette commande utilise le /execute dont je vous invite à retrouver un tutoriel dans un autre article)

Ici, chaque entité nommée Randomiseur va s’auto-appliquer une division avec reste où le diviseur sera la valeur de l’objectif Random pour un FakePlayer spécifié. Par exemple, si on veut obtenir au hasard une valeur parmi 10, il suffit de créer un FakePlayer (que nous appellerons “#10”) avec un score Random de 10. La commande suivante donnera donc à l’entité une valeur entre 0 et 9 :

/execute @e[name=Randomiseur] ~ ~ ~ scoreboard players operation @e[name=Randomiseur,r=0] Random %= #10 Random

Il ne reste qu’à mettre une incrémentation régulière du score pour obtenir le randomiseur, sachant qu’une commande dans un bloc repeating s’exécute 20 fois par seconde, additionner 1 au score via un /scoreboard suffira pour obtenir des valeurs correctement randomisées si le tirage ne se fait pas plus souvent que toutes les demi-secondes.

Troisième application : utiliser les minimums et maximums

Cette troisième application sera très peu utilisable ou courante, mais elle me permet de vous expliquer les deux opérations “<” et “>”. Imaginons un jeu où des joueurs doivent obtenir le score le plus élevé possible en réalisant certaines actions, mais qu’ils doivent réaliser d’autres actions pour augmenter le maximum de la valeur qu’ils peuvent atteindre, il conviendrait alors de bien alterner les deux activités.

Nous allons ici utiliser l’opération “<” ou “Minimum”, mais qu’il conviendrait mieux d’appeler “Limite supérieure”. Comme déjà évoqué dans la liste précédemment dressée, cette fonction va permettre de donner à la Cible la valeur de la Source si la Cible possède à l’origine une valeur supérieure à celle de la Source. C’est très confus dit comme ça, alors visualisons la commande et faisons des mathématiques sommaires.

Prenons la commande :

/scoreboard players operation X Objectif < Y Objectif

Ici, en prenant seulement le nom des joueurs et de l’opération, on peut lire : X < Y, soit Cible < Source. Il s’agit ici d’une condition qu’on veut respecter via une opération, on veut que la Cible soit inférieure à la Source pour que l’inéquation X < Y soit vraie.

Par conséquent, si la Cible a une valeur plus grande que la Source (soit Y < X), alors X va prendre la valeur de Y, hors comme il s’agit en réalité d’un “inférieur ou égal”, en donnant à X la valeur de Y on va vérifier l’inéquation X < Y. C’est donc pour cela qu’il vaudrait mieux désigner cette opération par “Limite supérieure”, si l’opération est appliquée régulièrement, X ne pourra pas dépasser Y.

Pour notre mini-jeu, si on stocke la valeur maximale dans un score de chaque joueur pour un objectif nommé “Maximum”, et que la valeur de score qui doit monter est “Score”, il suffira d’appliquer cette opération pour que chaque joueur ne puisse pas dépasser son propre maximum.

/execute @a ~ ~ ~ scoreboard players operation @p Score < @p Maximum

On peut simplifier si le “Maximum” est commun à tous les joueurs via un FakePlayer :

/scoreboard players operation @p Score < FakePlayer Maximum

Le même principe à l’opposé s’applique pour l’opération “>”. Donc pour s’assurer que le score de chaque joueur nommé X soit dans un intervalle du type A < X < B, il faut appliquer ces deux opérations :

/execute @a ~ ~ ~ scoreboard players operation @p X > @p A /execute @a ~ ~ ~ scoreboard players operation @p X < @p B

Quatrième application : Créer des classements

Si vous vous êtes déjà demandé comment afficher les trois meilleurs joueurs dans le chat par exemple, vous ne trouverez pas de solution simple. Et pourtant, avec un peu de math, on peut tout faire.

En récupérant le score la plus élevé avec l’opération ‘>’ puis en soustrayant à tous les joueurs ce score avec l’opération ‘-=’ le plus élevé, tous les joueurs se retrouvent alors avec un score négatif sauf celui ayant eu le meilleur score. Le meilleur joueur pourra donc être visé par les commandes plus facilement.

Première étape : Récupérer le score le plus élevé

/scoreboard players set #best score > @a score

Deuxième étape : Soustraire ce score à tous les joueurs

/scoreboard players operation @a score -= #best score

Annonce du meilleur :

/tellraw @a [{"text":"Et le vainqueur est : "},{"selector":"@a[score_score_min=0,score_score=0]"}]

Pour connaître le deuxième et le troisième, il suffit d’appliquer le même principe en ignorant le(s) joueur(s) mieux classé(s) (en les taggant ou en leur attribuant un score très bas).

Notez que si vous souhaitez conserver la valeur du score, vous pouvez utiliser la commande suivante pour stocker le score dans un objectif vous servant à faire les calculs :

/execute @a ~ ~ ~ /scoreboard players operation @p calcul = @p score


Le trigger :

J’espère ne pas vous avoir encore perdu à ce stade, parce que le /scoreboard players a encore plus d’un tour dans son sac. Nous allons maintenant de parler du “trigger” (déclencheur en français). Il s’agit d’un type d’objectif que nous n’avons pas développé dans la section précédente, car il est lié à des commandes /scoreboard players. Un objectif du type trigger va être utilisé afin qu’un joueur puisse définir son propre score pour certains objectifs, même sans droits sur un serveur ou sans que les commandes soient autorisées en solo.

Il nous faut d’abord créer un objectif de ce type que nous appeleront de façon très inspirée “Test” :

/scoreboard objectives add Test trigger

Une fois l’objectif créé, il faudra utiliser la commande ci-dessous afin d’autoriser le joueur à s’attribuer son propre score :

/scoreboard players enable <Joueur> <Objectif>

Il pourra alors modifier son propre score grâce à une autre commande nommée /trigger composée de cette façon :

/trigger <Objectif> <add|set> <Valeur>

Le fonctionnement des opérations add et set est la même que décrit précédemment en considérant que le joueur exécutant la commande est la cible. Cependant, après avoir autorisé la modification de score, le joueur ne pourra réaliser cette commande qu’une unique fois et aura besoin d’être reciblé par un “enable” à chaque fois qu’il voudra ré-appliquer une modification.

L’utilité est déjà évidente puisque la commande /trigger ne nécessite pas de droit pour être utilisée, mais elle trouve une application majeure dans les textes cliquables utilisant le JSON, car si un panneau cliquable exécute des commandes comme un bloc de commande, un texte en chat via /tellraw est soumis aux limitations de droits de la personne ayant cliqué.


Tester un NBT tag :

Si vos yeux vous tiraillent et que votre cerveau crie à l’agonie, et bien ils vont encore souffrir car nous ne sommes toujours pas à la fin ! Nous allons maintenant parler de l’utilisation du /scoreboard afin de tester la valeur des tags des entités ou joueur. En effet, au tout début de cette section, j’ai volontairement omis un paramètre optionnel dans min premier exemple. Il est en effet possible de placer à la toute fin de la commande un NBT tag, et seuls les joueurs correspondant à celui-ci seront affectés par la commande :

/scoreboard players <add|remove|set> <Joueur> <Objectif> <Valeur> [NBT tag]

Je ne détaillerai pas la structure d’un NBT tag, ni les tags les plus généraux, car ce tutoriel est déjà bien assez long. Vous pouvez en revanche retrouver des informations à leur sujet dans l’article sur le /summon de Mlakuss. Ici nous prendrons un exemple simple en testant si un joueur se trouve sur le sol :

/scoreboard players <add|remove|set> <Joueur> <Objectif> <Valeur> {OnGround:1b}

Remarque : il est obligatoire pour une majorité de tags lors d’un test de préciser une lettre après la valeur du tag, qui doit correspondre au type de variable utilisé par le tag, ici un byte (si vous voulez plus de détails à ce sujet, je vous invite à regarder ce tutoriel sur les formats de variables)


Les tags :

Vous pourrez bientôt relâcher votre souffle, il ne nous reste qu’un unique point à aborder sur le /scoreboard players qui n’est pas le plus compliqué. Il s’agit des tags, à bien différencier des NBT tags (bien qu’ils soient stockés dans un NBT tag). En effet, depuis la 1.9, il est possible d’attribuer ou retirer librement des tags à un joueur avec une commande de cette forme :

/scoreboard players tag <Joueur> <add|remove> <Tag> [NBT tag]

Le fonctionnement est proche du score sauf qu’au lieu d’attribuer une valeur, on va pouvoir donner ou retirer des tags par leur nom. Cela a l’énorme avantage de nous dispenser de créer un Objectif uniquement pour lui attribuer une valeur 0 ou 1, il suffit de donner ou retirer un tag. Il est ensuite possible de tester ce tag avec un sélecteur “tag=” :

/scoreboard players tag <Joueur> <add|remove> Test [NBT tag]

/testfor @a[tag=Test]

Le testfor trouvera tous les joueurs avec le tag “Test”. Cela est particulièrement pratique justement pour attribuer un tag au lieu d’un score lorsqu’on vérifie un NBT tag, comme précédemment évoqué. Il est bien sûr possible de donner plusieurs tags à un joueur, en revanche il ne peut y avoir qu’un seul sélecteur “tag=” ou “tag=!” (tester si un joueur n’a pas le tag) par ensemble de sélecteur, contrairement au score où il est possible d’en tester plusieurs en une fois (et on peut associer un tag et des scores).

Pocket Edition 0.15

Les équipes


Vous pouvez enfin souffler, nous en avons terminé avec les joueurs, et nous allons terminer ce tutoriel par du beaucoup moins compliqué : les équipes. Il s’agit de groupes de joueurs qu’on va regrouper afin de leur attribuer des règles spéciales entre-eux ou avec d’autres équipes, ainsi que pour les reconnaître via des sélecteurs.


Créer une équipe :

Pour créer une équipe, rien de plus simple, il suffit d’utiliser une commande comme suit :

/scoreboard teams add <Nom_de_team> [Nom d'affichage]

Voilà, votre team est créée. Pour la retirer, il suffit de remplacer “add” par “remove”. Le nom d’affichage est optionnel et ne sera visible que par les joueurs en mode spectateur. Il ne vous reste qu’à y ajouter des joueurs :

/scoreboard teams join <Nom_de_team> [Joueurs]

Bien entendu on peut utiliser sélecteur dans “Joueurs” pour en sélectionner ou en ajouter plusieurs d’un coup. Il est à noter que cet argument est optionnel, car si la commande est exécutée directement par un joueur (principalement pour des tests, l’execute pour join une team étant peu utile), il n’a pas besoin de préciser son nom.

Vous pourrez alors utiliser le sélecteur “team=Nom_de_team” pour tester si un joueur appartient à une équipe (ou n’appartient pas avec “team=!Nom_de_team”). Notez que ce sélecteur peut également être utilisé pour tester si un joueur n’est dans aucune team grâce à “team=”, ou si au contraire il en possède une avec “team=!”

Vous pouvez retirer un joueur de sa team grâce à la commande :

/scoreboard teams leave [Joueurs]

Vous pouvez également vider une team entière grâce à la commande :

/scoreboard teams empty [Team]


Paramètres des équipes :

La gestion des joueurs étant énoncée, nous pouvons passer aux différentes options des équipes. La commande de base est la suivante :

/scoreboard teams option <Nom_de_team> <option> <valeur>

Il existe plusieurs options que nous allons énoncer :

  • friendlyfire (true|false) : pour déterminer si les joueurs d’une même équipe peuvent s’infliger des dommages
  • seeFriendlyInvisibles (true|false) : pour déterminer si les joueurs peuvent voir leurs alliés possédant un effet d’invisibilité, ceux-ci sont alors montrés avec un effet de transparence

Transparence

  • nametagVisibility (always|hideForOwnTeam|hideForOtherTeams|never) : détermine qui pourra voir le nom des joueurs de l’équipe au-dessus de leur tête

Nametag

  • deathMessageVisibility (always|hideForOwnTeam|hideForOtherTeams|never) : de la même manière, détermine qui pourra voir les messages de mort des joueurs de l’équipe
  • collisionRule (always|pushOwnTeam|pushOtherTeams|never) : détermine avec qui le joueur aura un effet de collision
  • color : détermine la couleur du nom des joueurs de l’équipe

Color

 

J’ai volontairement gardé le “color” pourtant très courant d’utilisation pour la fin, afin de vous en montrer une petite utilisation. Lorsqu’utilisé dans la commande précédemment énoncée, il sera possible de lui donner un total de 16 valeurs pour 16 couleurs : “black”, “dark_blue”, “dark_green”, “dark_aqua”, “dark_red”, “dark_purple”, “gold”, “gray”, “dark_gray”, “blue”, “green”, “aqua”, “red”, “light_purple”, “yellow” ou “white”.

Remarque : Pour ceux s’en rappelant (bravo à vous au fait, vu que cela a été vu au tout début du tutoriel), ces valeurs sont utilisées dans certains paramètres afin de reconnaître l’équipe à laquelle appartient le joueur pour les stats killedByTeam et TeamKilled et les sidebars spécifiques aux équipes.

Cela modifiera en fait un préfixe et un suffixe au nom de chaque joueur afin de lui appliquer une couleur. Cependant, en bidouillant un peu les fichiers du jeu, on peut modifier ces préfixes et suffixes pour obtenir, en vanilla, ce genre de choses :

Modo rédac

Une discussion avec mon ami Skywebz m’apprenant à me servir de WordPress

Il faut simplement ouvrir le fichier “scoreboard.dat” avec NBT Explorer, comme déjà évoqué pour le nom d’affichage des objectifs. Cette fois-ci, on ouvrira le menu déroulant “Teams” et on tombera sur des ensembles correspondant chacun à une équipe. Les lignes qui nous intéressent sont “Prefix” et “Suffix”. Si vous voulez plus d’informations sur cette manipulation, vous pouvez consulter ce tutoriel sur le forum.

Scoreboard teams

On peut voir ici que le fait de mettre le “color” en “dark_red” a déjà placé le formatage §4 en préfixe pour que le nom soit rouge foncé

Remarque : Attention à ne pas faire des textes trop longs, la limite de taille d’un nom avec ses suffixes et préfixes restant la même qu’un nom seul, soit 16 caractères au total.

Pocket Edition 0.15

Le mot de la fin


Cet article était ma participation à la série de tutoriels de map-making. Gardez un œil sur le site, certains anciens tutoriels vont être révisés prochainement et d’autres plus globaux vont être réalisés. Il peut sembler étonnant de traiter le /scoreboard en dernier vu qu’il s’agit d’une des premières commandes de map-making apparue, néanmoins, comme vous avez pu voir par les nombreux renvois à d’autres articles ou tutoriels, chaque élément n’est en général exploité qu’en inter-dépendance avec d’autres. C’est ainsi qu’à chaque nouvelle mise à jour, par de grosses nouveautés ou de petits ajouts très demandés, le map-making minecraftien avance et avancera toujours. Si pour l’instant des contraintes techniques demeurent, les expectations pour le futur n’ont pour limite que l’imagination de chacun.

Je vous laisse pour terminer un petit rappel des autres articles et tutoriels, que vous allez évidemment vous empresser de consulter à la suite de celui-ci si ce n’est pas déjà fait :

Je vous invite également à consulter notre forum, où de nombreuses personnes postent régulièrement de nouveaux tutoriels. Si vous ne souhaitez pas chercher dans la globalité, il existe également un topic regroupant de nombreux liens vers des tutoriels ou outils utiles au map-making. C’est un peu comme un couteau Suisse cubique qui ferait en plus des boissons chaudes.

Vous pouvez également chercher de l’aide dans le support (pour vous, principalement dans la partie Mapping et Redstone), afin de corriger des erreurs ou d’améliorer vos créations.

À vos cubes, blocs de commandes, logiciels, et continuez de faire vivre la communauté Minecraft avec de nouveaux contenus !

A propos de Calambiel

Map-makeur terminant un projet pour dix entamés, étudiant en médecine pour 75% du temps, et modérateur forum pas vraiment chaleureux (on vient de la banquise ou on en vient pas).

Ceci vous intéresse peut être

[Guide] Le Nether

Le Nether est une dimension hostile regorgeant de dangers, mais aussi de trésors pour qui sait les obtenir. Dans ce guide, nous allons voir comment éviter les uns pour mieux cueillir les autres.

Rédiger une réponse

1 Commentaire sur "[Tutoriel] La commande /scoreboard"

Prévenez moi :
avatar
 
Trier par:   Commentaires récents | Commentaires ancients | Les mieux notés
Gleanight
Invité

Très bon tutoriel, très bien construit et rédigé :)
Je dois bien avouer que ton tutoriel m’a grandement aidé et je t’en remercie encore ^^

wpDiscuz