Garder les fonctions rapides

Les conventions que suivent les packs StewBeet dans le code exécuté à chaque tick. Chacune cite le helper qui l'applique quand il y en a un. Mesurez avant et après avec /perf start puis /perf stop : le zip produit contient server/profiling.txt, le temps pris par chaque commande.

Des entités persistantes plutôt que temporaires

execute summon ... run function ... suivi de kill @s crée et détruit une entité à chaque appel, ce qui coûte plus que la plupart de ce que fait ensuite la fonction. Une commande qui n'a besoin d'une entité que comme support (un item_display dans lequel faire loot replace entity @s contents, puis lire item) utilise une entité persistante :

python
from stewbeet import persistent_item_display, write_function

display: str = persistent_item_display("pulverizer_recipe")
write_function(f"{ns}:get_recipe", f"""
execute as {display} run function #{ns}:calls/recipes
data modify storage {ns}:main output set from entity {display} item
""")

persistent_item_display(name) ajoute à la fonction de load un forceload add du chunk de FORCELOAD_BLOCK (x -30000000, z 1600, partagé avec Bookshelf, Furnace NBT Recipes, et autres) et un execute unless entity <uuid> run summon de l'entité, une fois par nom. L'UUID est dérivé de l'id du projet et du nom : il ne change pas d'un build à l'autre et deux projets n'en partagent jamais un. La fonction d'unload tue l'entité et laisse le forceload aux autres packs qui utilisent ce chunk.

La position d'exécution reste celle de l'appelant : execute as <uuid> change @s, pas ~ ~ ~.

N'écrire le NBT d'une entité ou d'un bloc que s'il change

data modify entity et store result block sérialisent toute l'entité ou tout le bloc puis le rechargent. Protégez-les par un test peu coûteux de la valeur qu'ils écriraient :

mcfunction
execute unless items entity @s contents *[minecraft:item_model="ns:machine_on"] run data modify entity @s item.components."minecraft:item_model" set value "ns:machine_on"

Une valeur que le jeu fait avancer lui-même à chaque tick, comme le cooking_time_spent d'un four, n'est jamais égale à celle écrite au tick précédent. Écrivez-la plutôt quand ce que voit le joueur changerait : Furnace NBT Recipes l'écrit quand la flèche de progression afficherait un autre de ses 24 pixels.

Tester les items avec if items, pas en copiant leur NBT

data modify storage ... set from entity @s SelectedItem sérialise tout le joueur, inventaire compris, pour lire un seul item. execute if items lit directement le slot :

mcfunction
execute if items entity @s weapon.offhand *[custom_data~{"ns":{"multimeter":true}}] run function ns:multimeter
execute if items block ~ ~ ~ container.26 *[!custom_data~{"common_signals":{"temp":true}}] run function ns:drop_intruder

Ne copiez les Items d'un conteneur que sur le chemin qui a besoin de la pile complète, et au plus une fois par tick.

Lire un bloc une seule fois par tick

execute if data block ~ ~ ~ {lit_time_remaining:0} sérialise tout le bloc, items compris, pour une seule valeur. Quand une fonction a besoin de plusieurs valeurs, copiez le bloc une fois avec data modify storage ... set from block ~ ~ ~, passez en scores les valeurs testées plus d'une fois, et testez les slots avec if items block. Testez ce que l'état du bloc dit déjà avant cette copie : execute if block ~ ~ ~ #ns:furnaces[lit=true] dit si un four brûle sans le sérialiser, et un four éteint s'arrête avant.

Garder l'état d'une entité dans des scores et des tags

Une valeur qu'une entité lit et écrit à chaque tick (une progression, un slot débloqué) coûte une sérialisation complète de l'entité dans chaque sens quand elle vit dans son NBT. Stockez-la en score ou en tag sur l'entité, et ne la passez au NBT qu'à la pose ou à la casse du bloc, quand l'item la transporte. Une valeur qui ne change jamais tant que l'entité suit le bloc, comme le type de four, se lit une fois, au premier tick où son score manque : execute unless score @s ns.type matches 0.. run function ns:read_type.

Une valeur absente doit être absente

data modify storage ... set value {} avant un set from optionnel laisse {} quand la source manque, et execute unless data ne voit alors jamais l'absence. Videz plutôt avec data remove.

Réutiliser un résultat tant que son entrée ne change pas

data modify A set from B ne réussit que s'il modifie A, donc execute store success en fait un test d'égalité qui enregistre aussi la nouvelle valeur :

mcfunction
execute store success score #changed ns.data run data modify storage ns:temp previous_input set from storage ns:temp input
execute if score #changed ns.data matches 1 run function ns:expensive_lookup

Supprimez previous_input là où la réutilisation doit s'arrêter : au début du tick de chaque bloc, après qu'une commande a consommé le résultat, ou dans la fonction de load quand un /reload peut changer ce que la recherche renvoie.

Le même test compare deux compounds exactement : copiez l'un dans un chemin temporaire, puis execute store success ... run data modify <temporaire> set from <autre> donne 0 seulement s'ils sont égaux. Il remplace une macro qui lance if data dans les deux sens, qu'un appel de macro analyse à nouveau.

Ordonner une chaîne de returns par fréquence

Dans une fonction faite de lignes execute if ... run return <valeur>, mettez le cas le plus fréquent en premier, et vérifiez que chaque ligne teste la bonne cible (block ~ ~ ~ ou entity @s) : une ligne qui ne peut jamais réussir fait parcourir toute la chaîne à chaque appel.