
# 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.

