Comment faire : Définir le point d'apparition du joueur sur le point PRÉCÉDENT ?

Question

Situation : Serveur Java vanilla. Trois joueurs. Carte de taille normale. L'un des joueurs définit son point d'apparition sur un lit. Le lit se casse (pour X raison), le joueur meurt avant de pouvoir définir un nouveau point d'apparition, et est renvoyé au point d'apparition mondial.

Twist ! Le point d'apparition mondial est une chambre sous le monde où le joueur apparaît au-dessus, atterrissant sur une plaque de pression activant un bloc de commande pour les téléporter vers leur point d'apparition PRÉCÉDEMMENT enregistré. Dans ce cas, le lit noté qui a été détruit.

Twist 2 !! J'essaie de faire en sorte que la commande reconnaisse QUEL joueur active la plaque et les téléporte vers leur point d'apparition précédemment enregistré spécifique.

Est-ce que MC conserve un lit qui a été défini comme point d'apparition, même après que le lit a été cassé?

Si oui, où pourrait-on trouver ces données?

Et plus important encore, y a-t-il un moyen pour une commande de reconnaître QUEL joueur spécifique active la commande.

Answer 1

Détection du joueur mort

Détecter un joueur qui est mort est assez facile avec des commandes. Créez un scoreboard pour cela :

/scoreboard objectives add Deaths deathCount

Ensuite, vérifiez constamment si la valeur dans le scoreboard est supérieure à 0 :

# Chaque tick
execute as @a[scores={Death=1..}] run 

N'oubliez pas de remettre le score à 0 à la fin. Vous pouvez exécuter cette commande en utilisant des blocs de commande répétés ou en utilisant un datapack. Je recommande la deuxième option. Cela nécessite un peu plus de préparation, mais offre de meilleures performances et d'autres avantages.

Points d'apparition

Pour votre deuxième point : celui-ci est un peu plus difficile. Chaque joueur stocke les coordonnées de la tête du dernier lit dans lequel il a dormi, dans ses données NBT sous SpawnX, SpawnY et SpawnZ. Stocker cela dans un scoreboard n'est pas un problème. Créez trois scoreboards :

/scoreboard objectives add Spawn_X dummy
/scoreboard objectives add Spawn_Y dummy
/scoreboard objectives add Spawn_Z dummy

et stockez les valeurs pour chaque joueur :

# Chaque tick
execute as @a store result score @s Spawn_X run data get entity @s SpawnX
execute as @a store result score @s Spawn_Y run data get entity @s SpawnY
execute as @a store result score @s Spawn_Z run data get entity @s SpawnZ

Mais maintenant vient le problème : il n'y a pas de moyen direct d'insérer les valeurs du scoreboard dans une commande /teleport. Vous ne pouvez téléporter les joueurs qu'à un ensemble de coordonnées prédéfinies ou à une autre entité.

Solution possible

Voici une idée de ma part, sur comment vous pourriez réussir cela et les problèmes qui pourraient survenir. Je suppose d'après votre message que vous n'êtes pas extrêmement compétent en matière de commandes, donc cela pourrait être trop compliqué pour vous.

Vous pourriez créer une entité marqueur pour chaque joueur, qui marque leur point d'apparition. Vous auriez besoin de créer un lien entre le joueur et son marqueur, par exemple en utilisant un système d'ID. Il est possible de détecter quand un joueur change son point d'apparition en utilisant un deuxième ensemble de trois scoreboards (Spawn_X_new, Spawn_Y_new, Spawn_Z_new) et en vérifiant si au moins l'un d'entre eux est différent du vieux point d'apparition. Chaque fois que cela se produit, nous tuons l'ancien marqueur et invoquons un nouveau marqueur à la position du joueur.

# Chaque tick
# Mettre à jour le scoreboard
execute as @a store result score @s Spawn_X_new run data get entity @s SpawnX
execute as @a store result score @s Spawn_Y_new run data get entity @s SpawnY
execute as @a store result score @s Spawn_Z_new run data get entity @s SpawnZ

# Vérifier si quelque chose a changé
execute as @a unless score @s Spawn_X = @s Spawn_X_new at @s run function update_spawn
execute as @a if score @s Spawn_X = @s Spawn_X_new unless score @s Spawn_Y = @s Spawn_Y_new at @s run function update_spawn
execute as @a if score @s Spawn_X = @s Spawn_X_new if score @s Spawn_Y = @s Spawn_Y_new unless score @s Spawn_Z = @s Spawn_Z_new at @s run function update_spawn

# Mettre à jour les autres coordonnées
execute as @a store result score @s Spawn_X run scoreboard players get @s Spawn_X_new
execute as @a store result score @s Spawn_Y run scoreboard players get @s Spawn_Y_new
execute as @a store result score @s Spawn_Z run scoreboard players get @s Spawn_Z_new

# update_spawn.mcfunction
execute as @e[type=marker,tag=Respawn] if score @s ID = @p ID run kill @s
summon marker ~ ~ ~ {Tags:["Respawn"]}
execute store result score @e[type=marker,tag=Respawn,sort=nearest,limit=1] ID run scoreboard players get @s ID

Ensuite, chaque fois que le joueur meurt, nous le téléportons à son marqueur correspondant :

# Chaque tick
execute at @a[scores={Deaths=1..}] as @e[type=minecraft:marker,tag=Respawn] if score @s ID = @p ID run tp @p @s
scoreboard players set @a[scores={Deaths=1..}] Deaths 0

Le problème auquel nous sommes confrontés maintenant, est que l'entité marqueur correspondante pourrait ne pas être chargée si aucun joueur n'est à proximité. Nous pouvons contourner cela en utilisant /forceload lors de l'invocation des marqueurs.

# update_spawn.mcfunction
execute as @e[type=marker,tag=Respawn] if score @s ID = @p ID at @s run function 
summon marker ~ ~ ~ {Tags:["Respawn"]}
execute store result score @e[type=marker,tag=Respawn,sort=nearest,limit=1] ID run scoreboard players get @s ID
forceload add ~ ~