GastinelTpa 1.1.0 : /spawn, /rtp, /rtp spawn (blocs de commande), notation des beaux spots

- /spawn : spawn du monde (getSharedSpawnPos), délai annulé si mouvement/blessure, recharge.
- /rtp : zone déjà générée uniquement (chunk + 8 voisins complets sur disque, région absente
  jamais lue), atterrissage sûr, évite les claims GastinelClaims, recharge, messages FR.
- /rtp spawn : réservé aux blocs de commande, tirage pondéré parmi le top N de beaux-spots.json.
- /rtp diagnostic (op) : recherche sans téléportation, avec motifs de rejet.
- outils/beaux_spots.py : notation de beauté v0 sur une copie du monde.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
Theo GastineletClaude Sonnet 5.5 a révisé 2026-10-09 20:34:38 +02:00
1 Parent 3b34a46376
révision 53cfd9f02f
16 fichiers modifiés
+1443 -8

Aucun fichier ne correspond à votre recherche

+22
Voir le fichier
@@ -0,0 +1,22 @@
# GastinelTpa
Téléportations pour NeoForge 1.21.1 (21.1.234). **Mod côté serveur uniquement.**
## Commandes
- `/tpa <joueur>`, `/tpahere <joueur>`, `/tpaccept [joueur]`, `/tpadeny [joueur]` : demandes entre joueurs (expiration 1 min).
- `/spawn` : téléporte au point de spawn du monde (lu dans le monde via `getSharedSpawnPos()`, celui de `/setworldspawn`, aucune coordonnée en dur). Délai 3 s annulé si le joueur bouge ou est blessé, recharge 60 s.
- `/rtp` : endroit aléatoire dans la zone **déjà générée**, jamais de nouveau chunk. Délai 3 s (annulable), recharge 300 s. Atterrissage sûr : sol solide, pas d'eau (ni profonde à côté), pas de lave/feu/magma/cactus/baies/neige poudreuse/stalactite/rose du wither autour, pas de falaise > 3 blocs, pas sur les feuilles. Évite les claims GastinelClaims des autres (par réflexion, sans dépendance).
- `/rtp spawn [joueurs]` : **blocs de commande uniquement** (plaque de pression de l'entrée) ; joueur ou console -> refus avec un message clair. Sans argument : le joueur le plus proche du bloc (4 blocs). Choisit un « beau spot » de `beaux-spots.json` parmi les N meilleurs, tirage pondéré par le score (repli sur la zone /rtp si fichier absent).
- `/rtp diagnostic [spawn]` (op 2) : cherche un point comme /rtp sans téléporter personne et affiche les motifs de rejet. `/rtp recharger` (op 2) : relit `beaux-spots.json`.
## Comment /rtp évite toute génération
Un point n'est examiné que si le chunk **et ses 8 voisins** sont déjà chargés, ou présents sur le disque avec le statut `minecraft:full` (lecture asynchrone du NBT). Fichier région absent -> pas lu du tout (sinon Minecraft crée un `r.X.Z.mca` vide). Charger un chunk dont un voisin manque créerait un proto-chunk voisin pour l'éclairage, d'où la règle des voisins. Vérifié sur une copie du monde : 115 925 chunks avant/après, aucun fichier créé.
## Config
`<monde>/serverconfig/gastineltpa-server.toml` (rechargé à chaud) : délais, recharges, `essais` (100), zone `zoneXMin/XMax/ZMin/ZMax` (-512..6831 × -5632..1167, étendue mesurée le 09/10/2026 : 89 397 chunks complets, beaucoup d'océan), disque optionnel `zoneCentreX/Z` + `zoneRayon` (0 = rectangle seul), `rtpSpawn.topN` (60), `fichierSpots` (`config/gastineltpa/beaux-spots.json`).
## Beaux spots (notation v0)
`outils/beaux_spots.py` (+ `nbt_anvil.py`, `beaux-spots-config.json`) : lit une **copie** des fichiers région (jamais le monde en service), note chaque chunk complet (relief, vue, eau 5-30 %, végétation, variété/rareté des biomes, Terralith, sûreté ; pénalités océan profond, désert plat, danger), garde 300 spots espacés d'au moins 96 blocs, score 0-10. Lancer sur cornafserver : `nice -n 19 python3 -I beaux_spots.py --monde <copie-du-monde> --config beaux-spots-config.json --sortie beaux-spots.json` (82 s pour 89 397 chunks). Limite : les scores saturent près de 10 en tête (42 spots ≥ 9,5), le tirage pondéré du top 60 est donc presque uniforme.
## Build (sur cornafserver)
`sh envoyer-et-compiler.sh` depuis le PC, ou `sh build-sur-cornafserver.sh` sur le serveur (JDK 21 jetable, `nice`, 4 Go max). Tests JUnit (`core/`) puis `build/libs/gastineltpa-neoforge-1.21.1-1.1.0.jar`.
+1 -1
Voir le fichier
@@ -4,7 +4,7 @@
set -e set -e
cd "$(dirname "$0")" cd "$(dirname "$0")"
mkdir -p "$HOME/.cache/gastineltpa-gradle" mkdir -p "$HOME/.cache/gastineltpa-gradle"
docker run --rm \ nice -n 10 docker run --rm --memory 4g --cpus 4 \
-u "$(id -u):$(id -g)" \ -u "$(id -u):$(id -g)" \
-e GRADLE_USER_HOME=/gradle-home \ -e GRADLE_USER_HOME=/gradle-home \
-v "$HOME/.cache/gastineltpa-gradle:/gradle-home" \ -v "$HOME/.cache/gastineltpa-gradle:/gradle-home" \
+2 -2
Voir le fichier
@@ -2,9 +2,9 @@
# Depuis le PC : envoie les sources sur cornafserver (~/staging/GastinelTpa), compile, rapatrie le jar dans build-out/. # Depuis le PC : envoie les sources sur cornafserver (~/staging/GastinelTpa), compile, rapatrie le jar dans build-out/.
set -e set -e
cd "$(dirname "$0")" cd "$(dirname "$0")"
tar czf /tmp/gastineltpa-src.tgz --exclude=build --exclude=.gradle --exclude=build-out --exclude=run . tar czf /tmp/gastineltpa-src.tgz --exclude=build --exclude=.gradle --exclude=build-out --exclude=run --exclude=outils .
scp /tmp/gastineltpa-src.tgz cornafserver:gastineltpa-src.tgz scp /tmp/gastineltpa-src.tgz cornafserver:gastineltpa-src.tgz
ssh cornafserver 'set -e; rm -rf "$HOME/staging/GastinelTpa"; mkdir -p "$HOME/staging/GastinelTpa"; tar xzf "$HOME/gastineltpa-src.tgz" -C "$HOME/staging/GastinelTpa"; rm "$HOME/gastineltpa-src.tgz"; cd "$HOME/staging/GastinelTpa" && sh build-sur-cornafserver.sh' ssh cornafserver 'set -e; rm -rf "$HOME/staging/GastinelTpa"; mkdir -p "$HOME/staging/GastinelTpa"; tar xzf "$HOME/gastineltpa-src.tgz" -C "$HOME/staging/GastinelTpa"; rm "$HOME/gastineltpa-src.tgz"; cd "$HOME/staging/GastinelTpa" && sh build-sur-cornafserver.sh'
mkdir -p build-out mkdir -p build-out
scp 'cornafserver:staging/GastinelTpa/build/libs/gastineltpa-neoforge-1.21.1-1.0.0.jar' build-out/ scp 'cornafserver:staging/GastinelTpa/build/libs/gastineltpa-neoforge-1.21.1-1.1.0.jar' build-out/
ls -l build-out ls -l build-out
+1 -1
Voir le fichier
@@ -1,7 +1,7 @@
org.gradle.jvmargs=-Xmx2G org.gradle.jvmargs=-Xmx2G
org.gradle.parallel=true org.gradle.parallel=true
mod_version=1.0.0 mod_version=1.1.0
mod_group_id=com.gastineltpa mod_group_id=com.gastineltpa
mod_id=gastineltpa mod_id=gastineltpa
+37
Voir le fichier
@@ -0,0 +1,37 @@
{
"_doc": "Réglages de beaux_spots.py (version 0). Poids : importance relative de chaque critère (0 = ignoré). Les poids pen_* sont soustraits. Score final ramené sur 0-10.",
"zone": null,
"pas_grille_chunks": 1,
"rayon_voisinage_chunks": 3,
"rayon_vue_chunks": 6,
"espacement_min_blocs": 96,
"nombre_spots_max": 300,
"criteres": {
"relief_min": 6,
"relief_ideal": 45,
"relief_std_plat": 6,
"vue_ideal": 20,
"eau_min_ideal": 0.05,
"eau_max_ideal": 0.30,
"eau_trop": 0.75,
"canopee_min_ideal": 0.20,
"canopee_max_ideal": 0.60,
"biomes_varietes_ideal": 4,
"ocean_prof_seuil": 0.25,
"surete_vue_max": 40
},
"poids": {
"relief": 2.0,
"vue": 2.0,
"eau": 2.0,
"vegetation": 1.5,
"biome_variete": 1.0,
"biome_rarete": 1.0,
"terralith": 0.5,
"surete": 1.0,
"pen_ocean_profond": 3.0,
"pen_desert_plat": 2.0,
"pen_village": 0.0,
"pen_danger": 2.0
}
}
+327
Voir le fichier
@@ -0,0 +1,327 @@
#!/usr/bin/env python3
"""Notation de « beauté » des lieux d'un monde Minecraft prégénéré (version 0).
Lit en LECTURE SEULE les régions (.mca) d'une COPIE du monde, résume chaque chunk
(hauteurs, eau, arbres, biomes, sûreté d'atterrissage), puis note des candidats
(un par chunk, sur une grille) avec des critères pondérés définis dans un fichier JSON.
Produit beaux-spots.json, lu par le mod GastinelTpa pour /rtp spawn.
Usage (sur cornafserver, avec nice) :
nice -n 19 python3 -I beaux_spots.py --monde <copie-du-monde> \
--config beaux-spots-config.json --sortie beaux-spots.json [--echantillon 20]
Aucune écriture dans le monde : seuls level.dat et region/*.mca sont ouverts en lecture.
"""
import argparse
import glob
import json
import math
import os
import re
import sys
import time
from collections import Counter
from multiprocessing import Pool
import numpy as np
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from nbt_anvil import bits_pour, chunks_de_region, deplier, heightmap, lire_level_dat # noqa: E402
# Blocs sur lesquels on n'atterrit jamais (ou qu'on ne veut pas à côté des pieds).
DANGEREUX = {
"minecraft:lava", "minecraft:fire", "minecraft:soul_fire", "minecraft:magma_block",
"minecraft:cactus", "minecraft:sweet_berry_bush", "minecraft:campfire", "minecraft:soul_campfire",
"minecraft:powder_snow", "minecraft:pointed_dripstone", "minecraft:wither_rose",
}
LIQUIDES = {"minecraft:water", "minecraft:lava", "minecraft:bubble_column"}
SABLE = {"minecraft:sand", "minecraft:red_sand", "minecraft:sandstone", "minecraft:red_sandstone",
"minecraft:terracotta"}
RE_PAS_SOL = re.compile(r"(_log|_wood|_stem|_hyphae|leaves|_fence|_wall|_pane|glass|ice|"
r"bamboo|_slab|_stairs|_door|_trapdoor|scaffolding|chest|barrel|bed$|"
r"_sign|lantern|chain|bell|_rail|rail$|piston|hopper)")
def bloc_sur(nom):
"""Bloc plein « naturel » où l'on peut poser les pieds."""
if nom in DANGEREUX or nom in LIQUIDES:
return False
if nom in ("minecraft:air", "minecraft:cave_air", "minecraft:void_air"):
return False
return not RE_PAS_SOL.search(nom)
def _sections(nbt):
out = {}
for s in nbt.get("sections", []):
out[s.get("Y")] = s
return out
def _blocs_section(section, cache):
"""Tableau (4096,) d'indices + palette des noms, décodé une fois par section."""
y = section.get("Y")
if y in cache:
return cache[y]
bs = section.get("block_states") or {}
pal = [p.get("Name", "minecraft:air") for p in bs.get("palette", [])] or ["minecraft:air"]
data = bs.get("data")
if data is None or len(pal) == 1:
idx = np.zeros(4096, dtype=np.int64)
else:
idx = deplier(data, 4096, bits_pour(len(pal), 4))
cache[y] = (idx, pal)
return cache[y]
def _bloc(sections, cache, x, y, z):
sy = y >> 4
s = sections.get(sy)
if s is None:
return "minecraft:air"
idx, pal = _blocs_section(s, cache)
i = idx[((y & 15) * 16 + z) * 16 + x]
return pal[i] if i < len(pal) else "minecraft:air"
def _biome(sections, x, y, z):
s = sections.get(y >> 4)
if s is None:
return "?"
bm = s.get("biomes") or {}
pal = bm.get("palette", [])
if not pal:
return "?"
if len(pal) == 1 or bm.get("data") is None:
return pal[0]
vals = deplier(bm["data"], 64, bits_pour(len(pal), 1))
i = vals[(((y & 15) >> 2) * 4 + (z >> 2)) * 4 + (x >> 2)]
return pal[i] if i < len(pal) else "?"
def resumer_chunk(nbt):
"""Résumé compact d'un chunk FULL (None sinon)."""
if nbt.get("Status") not in ("minecraft:full", "full"):
return None
hm = nbt.get("Heightmaps") or {}
min_y = nbt.get("yPos", -4) * 16
sol = heightmap(hm.get("MOTION_BLOCKING_NO_LEAVES"), min_y) # sol, eau comprise, sans feuilles
fond = heightmap(hm.get("OCEAN_FLOOR"), min_y) # sol solide (sans liquides)
haut = heightmap(hm.get("MOTION_BLOCKING"), min_y) # avec feuilles
if sol is None or fond is None or haut is None:
return None
sections = _sections(nbt)
cache = {}
prof = sol - fond
canopee = haut > sol
# Blocs de surface : un sur deux (64 colonnes)
surf = Counter()
danger = 0
for z in range(0, 16, 2):
for x in range(0, 16, 2):
b = _bloc(sections, cache, x, int(sol[z, x]) - 1, z)
surf[b] += 1
if b in DANGEREUX:
danger += 1
# Colonne d'atterrissage : la plus proche du centre qui est sûre
meilleure = None
for d2, x, z in sorted(((x - 7.5) ** 2 + (z - 7.5) ** 2, x, z)
for x in range(2, 14) for z in range(2, 14)):
if prof[z, x] > 0:
continue
y = int(sol[z, x])
voisins = sol[z - 1:z + 2, x - 1:x + 2]
if voisins.max() - voisins.min() > 2 or (prof[z - 1:z + 2, x - 1:x + 2] > 0).any():
continue
if not bloc_sur(_bloc(sections, cache, x, y - 1, z)):
continue
if _bloc(sections, cache, x, y, z) not in ("minecraft:air", "minecraft:cave_air") and \
not _bloc(sections, cache, x, y, z).endswith(("short_grass", "fern", "snow")):
continue
if _bloc(sections, cache, x, y + 1, z) not in ("minecraft:air", "minecraft:cave_air"):
continue
if any(_bloc(sections, cache, x + dx, y - 1 + dy, z + dz) in DANGEREUX
for dx in (-1, 0, 1) for dz in (-1, 0, 1) for dy in (0, 1)):
continue
meilleure = (x, y, z)
break
biomes = Counter(_biome(sections, x, int(sol[z, x]), z) for x in (2, 13) for z in (2, 13))
centre_biome = _biome(sections, 8, int(sol[8, 8]), 8)
biomes[centre_biome] += 1
refs = (nbt.get("structures") or {}).get("References") or {}
village = any("village" in k for k in refs)
total = 64
return {
"h": float(sol.mean()), "hmin": int(sol.min()), "hmax": int(sol.max()),
"eau": float((prof > 0).mean()), "eau_prof": float((prof >= 4).mean()),
"canopee": float(canopee.mean()), "danger": danger / total,
"sable": sum(v for k, v in surf.items() if k in SABLE) / total,
"biome": centre_biome, "biomes": sorted(biomes),
"atterrissage": meilleure, "village": village,
}
def traiter_region(chemin):
m = re.search(r"r\.(-?\d+)\.(-?\d+)\.mca$", chemin)
rx, rz = int(m.group(1)), int(m.group(2))
out = {}
for lx, lz, nbt in chunks_de_region(chemin):
try:
r = resumer_chunk(nbt)
except Exception:
r = None
if r is not None:
out[(rx * 32 + lx, rz * 32 + lz)] = r
return out
# ---------- Notation ----------
def rampe(v, a, b):
"""0 sous a, 1 au-dessus de b, linéaire entre les deux."""
if b == a:
return 1.0 if v >= b else 0.0
return min(1.0, max(0.0, (v - a) / (b - a)))
def plateau(v, a, b, c, d):
"""0 avant a, monte jusqu'à b, 1 entre b et c, redescend à 0 en d."""
return min(rampe(v, a, b), 1.0 - rampe(v, c, d))
def noter(chunks, cfg):
c = cfg["criteres"]
p = cfg["poids"]
R = cfg.get("rayon_voisinage_chunks", 3)
RV = cfg.get("rayon_vue_chunks", 6)
pas = cfg.get("pas_grille_chunks", 1)
freq = Counter(r["biome"] for r in chunks.values())
fmax = max(freq.values())
candidats = []
for (cx, cz), r in chunks.items():
if cx % pas or cz % pas or r["atterrissage"] is None:
continue
voisins = [chunks.get((cx + dx, cz + dz)) for dx in range(-R, R + 1) for dz in range(-R, R + 1)]
voisins = [v for v in voisins if v is not None]
if len(voisins) < 0.8 * (2 * R + 1) ** 2:
continue # bord de la zone générée : voisinage incomplet
loin = [chunks.get((cx + dx, cz + dz)) for dx in range(-RV, RV + 1, 2) for dz in range(-RV, RV + 1, 2)]
loin = [v for v in loin if v is not None]
lx, ly, lz = r["atterrissage"]
hs = [v["h"] for v in voisins]
relief = max(v["hmax"] for v in voisins) - min(v["hmin"] for v in voisins)
vue = ly - float(np.mean([v["h"] for v in loin]))
eau = float(np.mean([v["eau"] for v in voisins]))
eau_prof = float(np.mean([v["eau_prof"] for v in voisins]))
canopee = float(np.mean([v["canopee"] for v in voisins]))
sable = float(np.mean([v["sable"] for v in voisins]))
danger = float(np.mean([v["danger"] for v in voisins]))
biomes = set()
for v in voisins:
biomes.update(v["biomes"])
biomes.discard("?")
rarete = 1.0 - freq[r["biome"]] / fmax
terralith = 1.0 if r["biome"].startswith("terralith:") else 0.0
s_relief = rampe(relief, c["relief_min"], c["relief_ideal"])
s_vue = rampe(vue, 0, c["vue_ideal"])
s_eau = plateau(eau, 0.0, c["eau_min_ideal"], c["eau_max_ideal"], c["eau_trop"])
s_veg = plateau(canopee, 0.0, c["canopee_min_ideal"], c["canopee_max_ideal"], 1.0)
s_var = rampe(len(biomes), 1, c["biomes_varietes_ideal"])
plat = 1.0 - rampe(float(np.std(hs)), 0, c["relief_std_plat"])
pen_ocean = rampe(eau_prof, c["ocean_prof_seuil"], 1.0)
pen_desert = sable * plat
pen_village = 1.0 if any(v["village"] for v in voisins) else 0.0
pen_danger = rampe(danger, 0.0, 0.1)
s_surete = 1.0 if abs(vue) < c["surete_vue_max"] else 0.5
detail = {
"relief": round(s_relief, 2), "vue": round(s_vue, 2), "eau": round(s_eau, 2),
"vegetation": round(s_veg, 2), "biome_variete": round(s_var, 2),
"biome_rarete": round(rarete, 2), "terralith": terralith, "surete": s_surete,
"pen_ocean_profond": round(pen_ocean, 2), "pen_desert_plat": round(pen_desert, 2),
"pen_village": pen_village, "pen_danger": round(pen_danger, 2),
}
positif = sum(p[k] for k in p if not k.startswith("pen_"))
brut = sum(p[k] * detail[k] for k in p if not k.startswith("pen_")) \
- sum(p[k] * detail[k] for k in p if k.startswith("pen_"))
score = 10.0 * min(1.0, max(0.0, brut / positif))
candidats.append({
"x": cx * 16 + lx, "y": ly, "z": cz * 16 + lz, "score": round(score, 2),
"biome": r["biome"],
"mesures": {"relief_blocs": relief, "vue_blocs": round(vue, 1), "eau": round(eau, 2),
"canopee": round(canopee, 2), "biomes_proches": len(biomes)},
"detail": detail,
})
candidats.sort(key=lambda s: -s["score"])
# Espacement minimal entre spots retenus
dmin2 = cfg.get("espacement_min_blocs", 96) ** 2
retenus = []
for s in candidats:
if all((s["x"] - t["x"]) ** 2 + (s["z"] - t["z"]) ** 2 >= dmin2 for t in retenus):
retenus.append(s)
if len(retenus) >= cfg.get("nombre_spots_max", 300):
break
return candidats, retenus, freq
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--monde", required=True)
ap.add_argument("--config", required=True)
ap.add_argument("--sortie", required=True)
ap.add_argument("--processus", type=int, default=3)
ap.add_argument("--echantillon", type=int, default=20)
a = ap.parse_args()
with open(a.config, encoding="utf-8") as f:
cfg = json.load(f)
t0 = time.time()
level = lire_level_dat(os.path.join(a.monde, "level.dat"))
zone = cfg.get("zone")
fichiers = sorted(glob.glob(os.path.join(a.monde, "region", "r.*.mca")))
if zone:
def dans_zone(fp):
m = re.search(r"r\.(-?\d+)\.(-?\d+)\.mca$", fp)
rx, rz = int(m.group(1)), int(m.group(2))
return (rx * 512 + 511 >= zone["xmin"] and rx * 512 <= zone["xmax"]
and rz * 512 + 511 >= zone["zmin"] and rz * 512 <= zone["zmax"])
fichiers = [fp for fp in fichiers if dans_zone(fp)]
chunks = {}
with Pool(a.processus) as pool:
for i, res in enumerate(pool.imap_unordered(traiter_region, fichiers)):
chunks.update(res)
print(f"\r{i + 1}/{len(fichiers)} régions, {len(chunks)} chunks", end="", file=sys.stderr)
print(file=sys.stderr)
if zone:
chunks = {k: v for k, v in chunks.items()
if zone["xmin"] <= k[0] * 16 + 8 <= zone["xmax"] and zone["zmin"] <= k[1] * 16 + 8 <= zone["zmax"]}
xs = [k[0] for k in chunks]
zs = [k[1] for k in chunks]
candidats, retenus, freq = noter(chunks, cfg)
scores = np.array([c["score"] for c in candidats]) if candidats else np.zeros(1)
sortie = {
"version": 0,
"genere_le": time.strftime("%Y-%m-%d %H:%M:%S"),
"monde": os.path.basename(os.path.normpath(a.monde)),
"spawn_monde": [level.get("SpawnX"), level.get("SpawnY"), level.get("SpawnZ")],
"bordure_monde": {"centre": [level.get("BorderCenterX"), level.get("BorderCenterZ")],
"taille": level.get("BorderSize")},
"etendue_generee": {"chunks_full": len(chunks),
"xmin": min(xs) * 16, "xmax": max(xs) * 16 + 15,
"zmin": min(zs) * 16, "zmax": max(zs) * 16 + 15},
"candidats_notes": len(candidats),
"repartition_scores": {"p50": round(float(np.percentile(scores, 50)), 2),
"p90": round(float(np.percentile(scores, 90)), 2),
"max": round(float(scores.max()), 2)},
"biomes_frequents": freq.most_common(15),
"config": cfg,
"spots": retenus,
}
with open(a.sortie, "w", encoding="utf-8") as f:
json.dump(sortie, f, ensure_ascii=False, indent=1)
print(f"{len(chunks)} chunks, {len(candidats)} candidats, {len(retenus)} spots retenus "
f"en {time.time() - t0:.0f} s -> {a.sortie}", file=sys.stderr)
for s in retenus[:a.echantillon]:
print(f"{s['score']:5.2f} ({s['x']}, {s['y']}, {s['z']}) {s['biome']} {s['mesures']}")
if __name__ == "__main__":
main()
+144
Voir le fichier
@@ -0,0 +1,144 @@
"""Lecture minimale (lecture seule) du format NBT et des régions Anvil (.mca) de Minecraft 1.21.
Aucune dépendance hors numpy. Ne modifie jamais les fichiers lus.
"""
import gzip
import struct
import zlib
import numpy as np
TAG_END, TAG_BYTE, TAG_SHORT, TAG_INT, TAG_LONG, TAG_FLOAT, TAG_DOUBLE = 0, 1, 2, 3, 4, 5, 6
TAG_BYTE_ARRAY, TAG_STRING, TAG_LIST, TAG_COMPOUND, TAG_INT_ARRAY, TAG_LONG_ARRAY = 7, 8, 9, 10, 11, 12
class _Lecteur:
__slots__ = ("b", "p")
def __init__(self, data):
self.b = data
self.p = 0
def u(self, fmt, n):
v = struct.unpack_from(fmt, self.b, self.p)[0]
self.p += n
return v
def chaine(self):
n = self.u(">H", 2)
s = self.b[self.p:self.p + n].decode("utf-8", "replace")
self.p += n
return s
def charge(self, t):
if t == TAG_BYTE:
return self.u(">b", 1)
if t == TAG_SHORT:
return self.u(">h", 2)
if t == TAG_INT:
return self.u(">i", 4)
if t == TAG_LONG:
return self.u(">q", 8)
if t == TAG_FLOAT:
return self.u(">f", 4)
if t == TAG_DOUBLE:
return self.u(">d", 8)
if t == TAG_BYTE_ARRAY:
n = self.u(">i", 4)
v = self.b[self.p:self.p + n]
self.p += n
return v
if t == TAG_STRING:
return self.chaine()
if t == TAG_LIST:
et = self.u(">b", 1)
n = self.u(">i", 4)
return [self.charge(et) for _ in range(n)]
if t == TAG_COMPOUND:
d = {}
while True:
ct = self.u(">b", 1)
if ct == TAG_END:
return d
nom = self.chaine()
d[nom] = self.charge(ct)
if t == TAG_INT_ARRAY:
n = self.u(">i", 4)
v = np.frombuffer(self.b, dtype=">i4", count=n, offset=self.p)
self.p += 4 * n
return v
if t == TAG_LONG_ARRAY:
n = self.u(">i", 4)
v = np.frombuffer(self.b, dtype=">u8", count=n, offset=self.p)
self.p += 8 * n
return v
raise ValueError(f"tag NBT inconnu {t}")
def lire_nbt(data):
r = _Lecteur(data)
t = r.u(">b", 1)
if t != TAG_COMPOUND:
raise ValueError("racine NBT non compound")
r.chaine()
return r.charge(TAG_COMPOUND)
def lire_level_dat(chemin):
with gzip.open(chemin, "rb") as f:
return lire_nbt(f.read())["Data"]
def chunks_de_region(chemin):
"""Itère (cx_local, cz_local, nbt) pour chaque chunk présent dans un fichier .mca."""
with open(chemin, "rb") as f:
data = f.read()
if len(data) < 8192:
return
for i in range(1024):
off = int.from_bytes(data[i * 4:i * 4 + 3], "big")
nsec = data[i * 4 + 3]
if off == 0 or nsec == 0:
continue
p = off * 4096
if p + 5 > len(data):
continue
longueur = int.from_bytes(data[p:p + 4], "big")
comp = data[p + 4]
brut = data[p + 5:p + 4 + longueur]
try:
if comp == 2:
nbt = lire_nbt(zlib.decompress(brut))
elif comp == 1:
nbt = lire_nbt(gzip.decompress(brut))
elif comp == 3:
nbt = lire_nbt(brut)
else:
continue # chunk externe (.mcc) ou compression inconnue : ignoré
except Exception:
continue
yield i % 32, i // 32, nbt
def deplier(longs, n_valeurs, bits):
"""Décode un tableau compacté (format 1.16+ : les valeurs ne chevauchent pas deux longs)."""
par_long = 64 // bits
masque = np.uint64((1 << bits) - 1)
a = np.asarray(longs, dtype=np.uint64)
decal = (np.arange(par_long, dtype=np.uint64) * np.uint64(bits))
vals = ((a[:, None] >> decal[None, :]) & masque).reshape(-1)
return vals[:n_valeurs].astype(np.int64)
def heightmap(longs, min_y):
"""Heightmap 16x16 -> tableau [z, x] de hauteurs absolues (premier bloc libre au-dessus)."""
if longs is None or len(longs) == 0:
return None
par_long = -(-256 // len(longs))
bits = 64 // par_long
return (deplier(longs, 256, bits) + min_y).reshape(16, 16)
def bits_pour(n, minimum):
b = max(1, (n - 1).bit_length())
return max(minimum, b) if n > 1 else 0
+54
Voir le fichier
@@ -0,0 +1,54 @@
package com.gastineltpa;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.neoforged.fml.ModList;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.UUID;
/**
* Lien optionnel vers GastinelClaims, par réflexion (pas de dépendance de compilation) :
* si le mod est absent ou change d'API, on considère qu'il n'y a pas de claim (et on le journalise une fois).
*/
final class ClaimsBridge {
private static boolean init;
private static Method get, registry, canAccess;
private static Constructor<?> chunkKey;
private ClaimsBridge() {}
private static synchronized boolean pret() {
if (init) return get != null;
init = true;
if (!ModList.get().isLoaded("gastinelclaims")) return false;
try {
Class<?> data = Class.forName("com.gastinelclaims.ClaimsData");
Class<?> reg = Class.forName("com.gastinelclaims.core.ClaimRegistry");
Class<?> key = Class.forName("com.gastinelclaims.core.ChunkKey");
get = data.getMethod("get", MinecraftServer.class);
registry = data.getMethod("registry");
canAccess = reg.getMethod("canAccess", UUID.class, key, boolean.class);
chunkKey = key.getConstructor(String.class, int.class, int.class);
GastinelTpa.LOGGER.info("[GastinelTpa] GastinelClaims détecté : /rtp évite les claims des autres.");
} catch (ReflectiveOperationException e) {
get = null;
GastinelTpa.LOGGER.warn("[GastinelTpa] API GastinelClaims introuvable, claims ignorés : {}", e.toString());
}
return get != null;
}
/** Vrai si le joueur a le droit d'être dans ce chunk (pas de claim, le sien, ou celui d'un ami). */
static boolean autorise(ServerLevel level, UUID joueur, int blocX, int blocZ) {
if (!pret()) return true;
try {
Object reg = registry.invoke(get.invoke(null, level.getServer()));
Object key = chunkKey.newInstance(level.dimension().location().toString(), blocX >> 4, blocZ >> 4);
return (Boolean) canAccess.invoke(reg, joueur, key, false);
} catch (ReflectiveOperationException | RuntimeException e) {
return true;
}
}
}
+7 -2
Voir le fichier
@@ -1,7 +1,9 @@
package com.gastineltpa; package com.gastineltpa;
import net.neoforged.bus.api.IEventBus; import net.neoforged.bus.api.IEventBus;
import net.neoforged.fml.ModContainer;
import net.neoforged.fml.common.Mod; import net.neoforged.fml.common.Mod;
import net.neoforged.fml.config.ModConfig;
import net.neoforged.neoforge.common.NeoForge; import net.neoforged.neoforge.common.NeoForge;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@@ -12,8 +14,11 @@ public class GastinelTpa {
public static final String MOD_ID = "gastineltpa"; public static final String MOD_ID = "gastineltpa";
public static final Logger LOGGER = LoggerFactory.getLogger(GastinelTpa.class); public static final Logger LOGGER = LoggerFactory.getLogger(GastinelTpa.class);
public GastinelTpa(IEventBus modEventBus) { public GastinelTpa(IEventBus modEventBus, ModContainer modContainer) {
// Config serveur : <monde>/serverconfig/gastineltpa-server.toml
modContainer.registerConfig(ModConfig.Type.SERVER, TpConfig.SPEC);
NeoForge.EVENT_BUS.register(TpaCommands.class); NeoForge.EVENT_BUS.register(TpaCommands.class);
LOGGER.info("[GastinelTpa] Demandes de téléportation chargées."); NeoForge.EVENT_BUS.register(SpawnRtpCommands.class);
LOGGER.info("[GastinelTpa] Téléportations chargées (/tpa, /spawn, /rtp).");
} }
} }
+506
Voir le fichier
@@ -0,0 +1,506 @@
package com.gastineltpa;
import com.gastineltpa.core.Cooldowns;
import com.gastineltpa.core.RtpLogic;
import com.gastineltpa.core.RtpLogic.Spot;
import com.gastineltpa.core.RtpLogic.Zone;
import com.gastineltpa.core.Warmups;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.minecraft.ChatFormatting;
import net.minecraft.commands.CommandSource;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.commands.Commands;
import net.minecraft.commands.arguments.EntityArgument;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.tags.BlockTags;
import net.minecraft.world.level.BaseCommandBlock;
import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.levelgen.Heightmap;
import net.minecraft.world.phys.Vec3;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.neoforge.event.RegisterCommandsEvent;
import net.neoforged.neoforge.event.entity.living.LivingDamageEvent;
import net.neoforged.neoforge.event.entity.player.PlayerEvent;
import net.neoforged.neoforge.event.server.ServerStartedEvent;
import net.neoforged.neoforge.event.tick.ServerTickEvent;
import java.io.Reader;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Consumer;
import java.util.function.Supplier;
/** /spawn, /rtp, /rtp spawn (blocs de commande), /rtp recharger (op). */
public final class SpawnRtpCommands {
private static final Cooldowns RECHARGES = new Cooldowns(System::currentTimeMillis);
private static final Warmups ATTENTES = new Warmups();
/** Action à lancer quand l'attente d'un joueur se termine. */
private static final Map<UUID, Runnable> ACTIONS = new HashMap<>();
/** Joueurs dont une recherche /rtp est en cours (évite les doublons). */
private static final java.util.Set<UUID> RECHERCHES = new java.util.HashSet<>();
private static volatile List<Spot> SPOTS = List.of();
@SubscribeEvent
public static void onRegister(RegisterCommandsEvent event) {
CommandDispatcher<CommandSourceStack> d = event.getDispatcher();
d.register(Commands.literal("spawn").executes(SpawnRtpCommands::spawn));
d.register(Commands.literal("rtp")
.executes(SpawnRtpCommands::rtp)
.then(Commands.literal("spawn")
.executes(ctx -> rtpSpawn(ctx, null))
.then(Commands.argument("joueurs", EntityArgument.players())
.executes(ctx -> rtpSpawn(ctx, EntityArgument.getPlayers(ctx, "joueurs")))))
.then(Commands.literal("diagnostic")
.requires(s -> s.hasPermission(2))
.executes(ctx -> diagnostic(ctx, false))
.then(Commands.literal("spawn").executes(ctx -> diagnostic(ctx, true))))
.then(Commands.literal("recharger")
.requires(s -> s.hasPermission(2))
.executes(ctx -> {
int n = chargerSpots(ctx.getSource().getServer());
ctx.getSource().sendSuccess(() -> info(n + " beaux spots chargés."), true);
return n;
})));
}
@SubscribeEvent
public static void onStarted(ServerStartedEvent event) {
chargerSpots(event.getServer());
}
// --- /spawn ---
private static int spawn(CommandContext<CommandSourceStack> ctx) throws CommandSyntaxException {
ServerPlayer p = ctx.getSource().getPlayerOrException();
if (!disponible(ctx, p, "spawn")) return 0;
int delai = TpConfig.get(TpConfig.SPAWN_DELAI);
demarrer(p, "spawn", delai, () -> {
ServerLevel monde = p.server.overworld();
BlockPos s = monde.getSharedSpawnPos();
BlockPos pieds = libre(monde, s) ? s
: new BlockPos(s.getX(), monde.getHeight(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, s.getX(), s.getZ()), s.getZ());
teleporter(p, monde, pieds, monde.getSharedSpawnAngle());
RECHARGES.start(p.getUUID(), "spawn", TpConfig.get(TpConfig.SPAWN_RECHARGE));
p.sendSystemMessage(succes("Bienvenue au spawn !"));
});
return 1;
}
// --- /rtp ---
private static int rtp(CommandContext<CommandSourceStack> ctx) throws CommandSyntaxException {
ServerPlayer p = ctx.getSource().getPlayerOrException();
if (!disponible(ctx, p, "rtp")) return 0;
if (RECHERCHES.contains(p.getUUID())) return echec(ctx, "Une recherche est déjà en cours.");
Zone zone = zone();
demarrer(p, "rtp", TpConfig.get(TpConfig.RTP_DELAI), () -> {
p.sendSystemMessage(info("Recherche d'un endroit sûr…"));
chercher(p, TpConfig.get(TpConfig.RTP_ESSAIS), () -> {
int[] xz = zone.tirer(ThreadLocalRandom.current());
return xz == null ? null : new BlockPos(xz[0], 0, xz[1]);
}, pos -> {
RECHARGES.start(p.getUUID(), "rtp", TpConfig.get(TpConfig.RTP_RECHARGE));
p.sendSystemMessage(succes("Téléporté en " + pos.getX() + " " + pos.getY() + " " + pos.getZ() + ". Bonne exploration !"));
});
});
return 1;
}
// --- /rtp spawn (blocs de commande uniquement) ---
private static int rtpSpawn(CommandContext<CommandSourceStack> ctx, Collection<ServerPlayer> cibles) {
CommandSourceStack src = ctx.getSource();
if (!depuisBlocDeCommande(src)) {
return echec(ctx, "/rtp spawn est réservé à la plaque de pression de l'entrée (bloc de commande). "
+ "Utilise /rtp pour une téléportation aléatoire.");
}
List<ServerPlayer> joueurs = new ArrayList<>();
if (cibles != null) {
joueurs.addAll(cibles);
} else {
// Sans argument : le joueur le plus proche du bloc, à 4 blocs maximum.
Vec3 o = src.getPosition();
ServerPlayer proche = null;
double best = 16.0;
for (ServerPlayer sp : src.getLevel().players()) {
double d2 = sp.position().distanceToSqr(o);
if (d2 <= best) {
best = d2;
proche = sp;
}
}
if (proche != null) joueurs.add(proche);
}
if (SPOTS.isEmpty()) {
GastinelTpa.LOGGER.warn("[GastinelTpa] /rtp spawn : aucun beau spot chargé ({}).", TpConfig.get(TpConfig.SPOTS_FICHIER));
}
int n = 0;
for (ServerPlayer p : joueurs) {
if (RECHERCHES.contains(p.getUUID())) continue;
if (RECHARGES.remaining(p.getUUID(), "rtpspawn") > 0) continue; // plaque : silencieux
RECHARGES.start(p.getUUID(), "rtpspawn", TpConfig.get(TpConfig.SPAWN_RTP_RECHARGE));
List<Spot> top = RtpLogic.top(SPOTS, TpConfig.get(TpConfig.SPAWN_RTP_TOP));
Zone zone = zone();
p.sendSystemMessage(info("En route vers un bel endroit de la carte…"));
chercher(p, TpConfig.get(TpConfig.RTP_ESSAIS), () -> {
ThreadLocalRandom r = ThreadLocalRandom.current();
Spot s = RtpLogic.tirerPondere(top, r);
if (s != null) return new BlockPos(s.x() + r.nextInt(-2, 3), 0, s.z() + r.nextInt(-2, 3));
int[] xz = zone.tirer(r); // aucun spot : repli sur la zone /rtp
return xz == null ? null : new BlockPos(xz[0], 0, xz[1]);
}, pos -> p.sendSystemMessage(succes("Bienvenue ! Tape /guide si tu veux de l'aide.")));
n++;
}
return n;
}
/** Op : cherche un point comme /rtp (ou /rtp spawn) sans téléporter personne, et l'affiche. */
private static int diagnostic(CommandContext<CommandSourceStack> ctx, boolean beauxSpots) {
CommandSourceStack src = ctx.getSource();
Zone zone = zone();
List<Spot> top = RtpLogic.top(SPOTS, TpConfig.get(TpConfig.SPAWN_RTP_TOP));
int[] tires = {0};
RAISONS.clear();
UUID personne = new UUID(0L, 0L);
rechercher(src.getServer(), personne, () -> true, TpConfig.get(TpConfig.RTP_ESSAIS), () -> {
tires[0]++;
ThreadLocalRandom r = ThreadLocalRandom.current();
if (beauxSpots && !top.isEmpty()) {
Spot s = RtpLogic.tirerPondere(top, r);
return new BlockPos(s.x() + r.nextInt(-2, 3), 0, s.z() + r.nextInt(-2, 3));
}
int[] xz = zone.tirer(r);
return xz == null ? null : new BlockPos(xz[0], 0, xz[1]);
}, pos -> {
String m = "[diagnostic] point sûr " + pos.getX() + " " + pos.getY() + " " + pos.getZ() + " après " + tires[0] + " tirage(s)" + " ; rejets : " + RAISONS;
GastinelTpa.LOGGER.info("[GastinelTpa] {}", m);
src.sendSuccess(() -> info(m), false);
}, () -> {
String m = "[diagnostic] aucun point sûr après " + tires[0] + " tirage(s)" + " ; rejets : " + RAISONS;
GastinelTpa.LOGGER.info("[GastinelTpa] {}", m);
src.sendSuccess(() -> erreur(m), false);
});
return 1;
}
/** Vrai si la commande vient d'un bloc de commande (ou d'un minecart de commande). */
static boolean depuisBlocDeCommande(CommandSourceStack src) {
if (src.getEntity() instanceof ServerPlayer) return false;
try {
Field f = CommandSourceStack.class.getDeclaredField("source");
f.setAccessible(true);
CommandSource s = (CommandSource) f.get(src);
return s instanceof BaseCommandBlock;
} catch (ReflectiveOperationException | RuntimeException e) {
GastinelTpa.LOGGER.warn("[GastinelTpa] Source de commande illisible, /rtp spawn refusé : {}", e.toString());
return false;
}
}
// --- Recherche asynchrone d'un point sûr (jamais de génération de chunk) ---
/** Recherche pour un joueur : téléporte au premier point sûr, sinon message d'échec. */
private static void chercher(ServerPlayer p, int essais, Supplier<BlockPos> tirage, Consumer<BlockPos> ok) {
RECHERCHES.add(p.getUUID());
rechercher(p.server, p.getUUID(), () -> !p.isRemoved() && p.server.getPlayerList().getPlayer(p.getUUID()) != null,
essais, tirage, pos -> {
RECHERCHES.remove(p.getUUID());
teleporter(p, p.server.overworld(), pos, p.getYRot());
ok.accept(pos);
}, () -> {
RECHERCHES.remove(p.getUUID());
p.sendSystemMessage(erreur("Aucun endroit sûr trouvé après plusieurs essais. Réessaie dans un instant."));
});
}
/**
* Essaie jusqu'à {@code restants} points tirés. Un point n'est examiné que si son chunk est déjà chargé ou
* présent sur le disque avec le statut « full » ; la colonne testée est gardée à l'intérieur du chunk
* (bords exclus) pour que la vérification des voisins ne touche jamais un autre chunk.
*/
static void rechercher(MinecraftServer server, UUID joueur, java.util.function.BooleanSupplier actif, int restants,
Supplier<BlockPos> tirage, Consumer<BlockPos> ok, Runnable echec) {
if (!actif.getAsBoolean()) {
RECHERCHES.remove(joueur);
return;
}
BlockPos tire = restants > 0 ? tirage.get() : null;
if (tire == null) {
echec.run();
return;
}
int cx = tire.getX() >> 4, cz = tire.getZ() >> 4;
BlockPos xz = new BlockPos((cx << 4) + Math.clamp(tire.getX() & 15, 1, 14), 0,
(cz << 4) + Math.clamp(tire.getZ() & 15, 1, 14));
ServerLevel monde = server.overworld();
Runnable suivant = () -> rechercher(server, joueur, actif, restants - 1, tirage, ok, echec);
if (!monde.getWorldBorder().isWithinBounds(xz) || !ClaimsBridge.autorise(monde, joueur, xz.getX(), xz.getZ())) {
note("bordure-ou-claim");
server.execute(suivant);
return;
}
Runnable verifier = () -> {
if (!actif.getAsBoolean()) {
RECHERCHES.remove(joueur);
return;
}
Optional<BlockPos> pieds = pointSur(monde, xz.getX(), xz.getZ());
if (pieds.isPresent()) ok.accept(pieds.get());
else server.execute(suivant);
};
// Le chunk ET ses 8 voisins doivent être complets (chargés, ou « full » sur le disque) : charger un chunk
// dont un voisin manque ferait créer ce voisin (proto-chunk) pour l'éclairage = génération. Lecture sur
// le thread d'E/S ; absent ou incomplet -> point refusé, rien n'est généré.
List<java.util.concurrent.CompletableFuture<String>> lectures = new ArrayList<>();
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int ccx = cx + i, ccz = cz + j;
if (monde.getChunkSource().getChunkNow(ccx, ccz) != null) continue;
// Fichier région absent : on ne le lit pas (la lecture créerait un r.X.Z.mca vide).
Path region = server.getWorldPath(net.minecraft.world.level.storage.LevelResource.ROOT)
.resolve("region").resolve("r." + (ccx >> 5) + "." + (ccz >> 5) + ".mca");
try {
if (!Files.isRegularFile(region) || Files.size(region) < 8192) {
note("region-absente");
server.execute(suivant);
return;
}
} catch (java.io.IOException e) {
note("region-illisible");
server.execute(suivant);
return;
}
lectures.add(monde.getChunkSource().chunkMap.read(new ChunkPos(ccx, ccz))
.handle((opt, err) -> err != null ? "lecture-erreur"
: opt.isEmpty() ? "chunk-absent"
: complet(opt.get()) ? null : "chunk-incomplet"));
}
}
if (lectures.isEmpty()) {
verifier.run();
return;
}
java.util.concurrent.CompletableFuture.allOf(lectures.toArray(new java.util.concurrent.CompletableFuture[0]))
.whenComplete((v, e) -> server.execute(() -> {
String probleme = null;
for (var f : lectures) {
String r = f.getNow("lecture-erreur");
if (r != null) {
probleme = r;
break;
}
}
if (probleme == null) verifier.run();
else {
note(probleme);
suivant.run();
}
}));
}
/** Motifs de rejet (pour /rtp diagnostic). */
static final java.util.concurrent.ConcurrentHashMap<String, Integer> RAISONS = new java.util.concurrent.ConcurrentHashMap<>();
private static void note(String raison) {
RAISONS.merge(raison.length() > 60 ? raison.substring(0, 60) : raison, 1, Integer::sum);
}
private static Optional<BlockPos> rejet(String raison) {
note(raison);
return Optional.empty();
}
private static boolean complet(CompoundTag tag) {
String s = tag.getString("Status");
return "minecraft:full".equals(s) || "full".equals(s);
}
/** Position des pieds si la colonne (x, z) est sûre, sinon vide. Le chunk doit exister (complet). */
static Optional<BlockPos> pointSur(ServerLevel monde, int x, int z) {
// Chargement explicite (depuis le disque, chunk complet vérifié avant) : Level.getHeight() renvoie
// la hauteur minimale pour un chunk non chargé.
net.minecraft.world.level.chunk.LevelChunk chunk = monde.getChunk(x >> 4, z >> 4);
int y = chunk.getHeight(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x & 15, z & 15) + 1;
if (y <= monde.getMinBuildHeight() + 5 || y >= monde.getMaxBuildHeight() - 2) return rejet("hauteur");
BlockPos pieds = new BlockPos(x, y, z);
BlockPos sol = pieds.below();
BlockState s = monde.getBlockState(sol);
if (!s.getFluidState().isEmpty() || s.is(BlockTags.LEAVES) || s.is(BlockTags.LOGS)
|| dangereux(s) || !s.isFaceSturdy(monde, sol, Direction.UP)) return rejet("sol:" + BuiltInRegistries.BLOCK.getKey(s.getBlock()).getPath());
if (!libre(monde, pieds)) return rejet("pas-libre");
for (int dx = -1; dx <= 1; dx++) {
for (int dz = -1; dz <= 1; dz++) {
for (int dy = -1; dy <= 1; dy++) {
BlockState v = monde.getBlockState(pieds.offset(dx, dy, dz));
if (dangereux(v) || v.getFluidState().is(net.minecraft.tags.FluidTags.LAVA)) return rejet("danger-voisin");
}
// Pas de falaise ni de trou juste à côté
int h = monde.getHeight(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x + dx, z + dz);
if (Math.abs(h - y) > 3) return rejet("pente");
if (!monde.getBlockState(new BlockPos(x + dx, h - 1, z + dz)).getFluidState().isEmpty() && (dx != 0 || dz != 0)) {
// eau voisine tolérée seulement si peu profonde
if (!monde.getBlockState(new BlockPos(x + dx, h - 3, z + dz)).getFluidState().isEmpty()) return rejet("eau-profonde-voisine");
}
}
}
return Optional.of(pieds);
}
private static boolean dangereux(BlockState s) {
return RtpLogic.dangereux(BuiltInRegistries.BLOCK.getKey(s.getBlock()).toString());
}
private static boolean libre(ServerLevel monde, BlockPos pieds) {
for (BlockPos b : new BlockPos[]{pieds, pieds.above()}) {
BlockState s = monde.getBlockState(b);
if (!s.getCollisionShape(monde, b).isEmpty() || !s.getFluidState().isEmpty() || dangereux(s)) return false;
}
return true;
}
// --- Délai, annulation, recharge ---
private static boolean disponible(CommandContext<CommandSourceStack> ctx, ServerPlayer p, String cmd) {
int reste = RECHARGES.remaining(p.getUUID(), cmd);
if (reste > 0) {
echec(ctx, "Patiente encore " + duree(reste) + " avant de refaire /" + cmd + ".");
return false;
}
return true;
}
private static void demarrer(ServerPlayer p, String cmd, int delaiSecondes, Runnable action) {
if (delaiSecondes <= 0) {
action.run();
return;
}
ATTENTES.start(p.getUUID(), cmd, p.getX(), p.getY(), p.getZ(), delaiSecondes * 20);
ACTIONS.put(p.getUUID(), action);
p.sendSystemMessage(info("Téléportation dans " + delaiSecondes + " s, ne bouge pas…"));
}
@SubscribeEvent
public static void onTick(ServerTickEvent.Post event) {
MinecraftServer server = event.getServer();
for (Warmups.Resultat r : ATTENTES.tick(id -> {
ServerPlayer sp = server.getPlayerList().getPlayer(id);
return sp == null ? null : new double[]{sp.getX(), sp.getY(), sp.getZ()};
})) {
Runnable action = ACTIONS.remove(r.joueur());
ServerPlayer sp = server.getPlayerList().getPlayer(r.joueur());
if (sp == null) continue;
if (r.fin() == Warmups.Fin.BOUGE) {
sp.sendSystemMessage(erreur("Téléportation annulée : tu as bougé."));
} else if (action != null) {
action.run();
}
}
}
@SubscribeEvent
public static void onDamage(LivingDamageEvent.Post event) {
if (event.getEntity() instanceof ServerPlayer sp && ATTENTES.cancel(sp.getUUID()) != null) {
ACTIONS.remove(sp.getUUID());
sp.sendSystemMessage(erreur("Téléportation annulée : tu as été blessé."));
}
}
@SubscribeEvent
public static void onLogout(PlayerEvent.PlayerLoggedOutEvent event) {
UUID id = event.getEntity().getUUID();
ATTENTES.cancel(id);
ACTIONS.remove(id);
RECHERCHES.remove(id);
}
// --- Beaux spots ---
static int chargerSpots(MinecraftServer server) {
Path f = server.getServerDirectory().resolve(TpConfig.get(TpConfig.SPOTS_FICHIER));
if (!Files.isRegularFile(f)) {
SPOTS = List.of();
GastinelTpa.LOGGER.warn("[GastinelTpa] Fichier de beaux spots absent : {} (/rtp spawn utilisera la zone /rtp).", f);
return 0;
}
try (Reader r = Files.newBufferedReader(f, StandardCharsets.UTF_8)) {
JsonObject racine = JsonParser.parseReader(r).getAsJsonObject();
JsonArray tab = racine.getAsJsonArray("spots");
List<Spot> l = new ArrayList<>();
for (JsonElement e : tab) {
JsonObject o = e.getAsJsonObject();
l.add(new Spot(o.get("x").getAsInt(), o.get("y").getAsInt(), o.get("z").getAsInt(),
o.get("score").getAsDouble(), o.has("biome") ? o.get("biome").getAsString() : "?"));
}
SPOTS = List.copyOf(l);
GastinelTpa.LOGGER.info("[GastinelTpa] {} beaux spots chargés depuis {}.", l.size(), f);
return l.size();
} catch (Exception e) {
GastinelTpa.LOGGER.error("[GastinelTpa] Lecture de {} impossible : {}", f, e.toString());
return 0;
}
}
private static Zone zone() {
return new Zone(TpConfig.get(TpConfig.ZONE_X_MIN), TpConfig.get(TpConfig.ZONE_X_MAX),
TpConfig.get(TpConfig.ZONE_Z_MIN), TpConfig.get(TpConfig.ZONE_Z_MAX),
TpConfig.get(TpConfig.ZONE_CENTRE_X), TpConfig.get(TpConfig.ZONE_CENTRE_Z),
TpConfig.get(TpConfig.ZONE_RAYON));
}
// --- Utilitaires ---
private static void teleporter(ServerPlayer p, ServerLevel monde, BlockPos pieds, float yaw) {
p.stopRiding();
p.teleportTo(monde, pieds.getX() + 0.5, pieds.getY(), pieds.getZ() + 0.5, yaw, p.getXRot());
p.fallDistance = 0;
}
private static String duree(int s) {
return s >= 60 ? (s / 60) + " min " + (s % 60) + " s" : s + " s";
}
private static int echec(CommandContext<CommandSourceStack> ctx, String message) {
ctx.getSource().sendFailure(Component.literal(message));
return 0;
}
private static Component info(String s) {
return Component.literal("[TP] ").withStyle(ChatFormatting.GOLD)
.append(Component.literal(s).withStyle(ChatFormatting.YELLOW));
}
private static Component succes(String s) {
return Component.literal("[TP] ").withStyle(ChatFormatting.GOLD)
.append(Component.literal(s).withStyle(ChatFormatting.GREEN));
}
private static Component erreur(String s) {
return Component.literal("[TP] ").withStyle(ChatFormatting.GOLD)
.append(Component.literal(s).withStyle(ChatFormatting.RED));
}
}
+75
Voir le fichier
@@ -0,0 +1,75 @@
package com.gastineltpa;
import net.neoforged.neoforge.common.ModConfigSpec;
/** config/gastineltpa-server.toml (fichier serveur, rechargé à chaud par NeoForge). */
public final class TpConfig {
public static final ModConfigSpec SPEC;
public static final ModConfigSpec.IntValue SPAWN_DELAI;
public static final ModConfigSpec.IntValue SPAWN_RECHARGE;
public static final ModConfigSpec.IntValue RTP_DELAI;
public static final ModConfigSpec.IntValue RTP_RECHARGE;
public static final ModConfigSpec.IntValue RTP_ESSAIS;
public static final ModConfigSpec.IntValue ZONE_X_MIN, ZONE_X_MAX, ZONE_Z_MIN, ZONE_Z_MAX;
public static final ModConfigSpec.IntValue ZONE_CENTRE_X, ZONE_CENTRE_Z, ZONE_RAYON;
public static final ModConfigSpec.IntValue SPAWN_RTP_RECHARGE;
public static final ModConfigSpec.IntValue SPAWN_RTP_TOP;
public static final ModConfigSpec.ConfigValue<String> SPOTS_FICHIER;
static {
ModConfigSpec.Builder b = new ModConfigSpec.Builder();
b.comment("/spawn : téléporte au point de spawn du monde (lu dans level.dat, défini par /setworldspawn).")
.push("spawn");
SPAWN_DELAI = b.comment("Délai avant téléportation, en secondes (annulé si le joueur bouge ou est blessé).")
.defineInRange("delaiSecondes", 3, 0, 60);
SPAWN_RECHARGE = b.comment("Temps de recharge entre deux /spawn, en secondes.")
.defineInRange("rechargeSecondes", 60, 0, 86400);
b.pop();
b.comment("/rtp : téléportation aléatoire dans la zone DÉJÀ générée (jamais de nouveau chunk).")
.push("rtp");
RTP_DELAI = b.comment("Délai avant téléportation, en secondes.").defineInRange("delaiSecondes", 3, 0, 60);
RTP_RECHARGE = b.comment("Temps de recharge entre deux /rtp, en secondes.")
.defineInRange("rechargeSecondes", 300, 0, 86400);
RTP_ESSAIS = b.comment("Nombre d'endroits essayés avant d'abandonner.").defineInRange("essais", 100, 1, 300);
b.comment("Zone de tirage (blocs). Mesuré le 09/10/2026 sur une copie de neW512 (outils/beaux_spots.py) :",
"89 397 chunks complets, de x -512..6831 et z -5632..1167 (pas un rectangle plein : beaucoup",
"d'océan). Pas de worldborder (vanilla). Les chunks absents du disque sont toujours refusés.");
ZONE_X_MIN = b.defineInRange("zoneXMin", -512, -30000000, 30000000);
ZONE_X_MAX = b.defineInRange("zoneXMax", 6831, -30000000, 30000000);
ZONE_Z_MIN = b.defineInRange("zoneZMin", -5632, -30000000, 30000000);
ZONE_Z_MAX = b.defineInRange("zoneZMax", 1167, -30000000, 30000000);
ZONE_CENTRE_X = b.comment("Centre du disque autorisé (avec zoneRayon).")
.defineInRange("zoneCentreX", 5566, -30000000, 30000000);
ZONE_CENTRE_Z = b.defineInRange("zoneCentreZ", -990, -30000000, 30000000);
ZONE_RAYON = b.comment("Rayon du disque autorisé ; 0 = rectangle seul.")
.defineInRange("zoneRayon", 0, 0, 30000000);
b.pop();
b.comment("/rtp spawn : réservé aux blocs de commande (plaque de pression de l'entrée).").push("rtpSpawn");
SPAWN_RTP_RECHARGE = b.comment("Recharge par joueur, en secondes (évite les doubles déclenchements).")
.defineInRange("rechargeSecondes", 10, 0, 86400);
SPAWN_RTP_TOP = b.comment("Tirage parmi les N meilleurs spots de beaux-spots.json (pondéré par le score).")
.defineInRange("topN", 60, 1, 100000);
SPOTS_FICHIER = b.comment("Fichier des spots, relatif au dossier du serveur. Rechargé par /rtp recharger (op).")
.define("fichierSpots", "config/gastineltpa/beaux-spots.json");
b.pop();
SPEC = b.build();
}
static int get(ModConfigSpec.IntValue v) {
return SPEC.isLoaded() ? v.get() : v.getDefault();
}
static String get(ModConfigSpec.ConfigValue<String> v) {
return SPEC.isLoaded() ? v.get() : v.getDefault();
}
private TpConfig() {}
}
+42
Voir le fichier
@@ -0,0 +1,42 @@
package com.gastineltpa.core;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.function.LongSupplier;
/** Temps de recharge par joueur et par commande. Logique pure, horloge injectable. */
public final class Cooldowns {
private final LongSupplier clock;
private final Map<String, Long> fin = new HashMap<>();
public Cooldowns(LongSupplier clockMs) {
this.clock = clockMs;
}
private static String cle(UUID joueur, String commande) {
return commande + "|" + joueur;
}
/** Démarre la recharge (durée en secondes ; 0 ou moins = pas de recharge). */
public void start(UUID joueur, String commande, int secondes) {
if (secondes <= 0) {
fin.remove(cle(joueur, commande));
return;
}
fin.put(cle(joueur, commande), clock.getAsLong() + secondes * 1000L);
}
/** Secondes restantes (arrondi supérieur), 0 si la commande est disponible. */
public int remaining(UUID joueur, String commande) {
Long f = fin.get(cle(joueur, commande));
if (f == null) return 0;
long reste = f - clock.getAsLong();
if (reste <= 0) {
fin.remove(cle(joueur, commande));
return 0;
}
return (int) ((reste + 999) / 1000);
}
}
+67
Voir le fichier
@@ -0,0 +1,67 @@
package com.gastineltpa.core;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.random.RandomGenerator;
/** Règles pures de /rtp : zone, blocs dangereux, tirage pondéré des beaux spots. */
public final class RtpLogic {
private RtpLogic() {}
/** Blocs sur lesquels (ou à côté desquels) on n'atterrit jamais. */
public static final Set<String> DANGEREUX = Set.of(
"minecraft:lava", "minecraft:fire", "minecraft:soul_fire", "minecraft:magma_block",
"minecraft:cactus", "minecraft:sweet_berry_bush", "minecraft:campfire", "minecraft:soul_campfire",
"minecraft:powder_snow", "minecraft:pointed_dripstone", "minecraft:wither_rose");
public static boolean dangereux(String id) {
return DANGEREUX.contains(id);
}
/** Rectangle de la zone autorisée (bornes incluses, en blocs) + rayon optionnel autour d'un centre. */
public record Zone(int xMin, int xMax, int zMin, int zMax, int centreX, int centreZ, int rayon) {
public boolean contient(int x, int z) {
if (x < xMin || x > xMax || z < zMin || z > zMax) return false;
if (rayon <= 0) return true;
long dx = x - centreX, dz = z - centreZ;
return dx * dx + dz * dz <= (long) rayon * rayon;
}
/** Tire un point de la zone (rejet si hors du disque) ; null si la zone est vide. */
public int[] tirer(RandomGenerator rnd) {
if (xMax < xMin || zMax < zMin) return null;
for (int i = 0; i < 64; i++) {
int x = xMin + rnd.nextInt(xMax - xMin + 1);
int z = zMin + rnd.nextInt(zMax - zMin + 1);
if (contient(x, z)) return new int[]{x, z};
}
return null;
}
}
public record Spot(int x, int y, int z, double score, String biome) {}
/** Les N meilleurs spots (score décroissant). */
public static List<Spot> top(List<Spot> spots, int n) {
List<Spot> l = new ArrayList<>(spots);
l.sort(Comparator.comparingDouble(Spot::score).reversed());
return l.subList(0, Math.min(Math.max(0, n), l.size()));
}
/** Tirage pondéré par le score (score <= 0 : poids nul, sauf si tous sont nuls). */
public static Spot tirerPondere(List<Spot> spots, RandomGenerator rnd) {
if (spots.isEmpty()) return null;
double total = 0;
for (Spot s : spots) total += Math.max(0, s.score());
if (total <= 0) return spots.get(rnd.nextInt(spots.size()));
double r = rnd.nextDouble() * total;
for (Spot s : spots) {
r -= Math.max(0, s.score());
if (r < 0) return s;
}
return spots.get(spots.size() - 1);
}
}
+71
Voir le fichier
@@ -0,0 +1,71 @@
package com.gastineltpa.core;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Téléportations en attente (délai avant départ). Annulées si le joueur bouge ou est blessé.
* Logique pure : on lui donne les positions à chaque tick.
*/
public final class Warmups {
/** Distance maximale tolérée (en blocs) avant annulation. */
public static final double TOLERANCE = 0.6;
public enum Fin { PRET, BOUGE }
public record Attente(UUID joueur, String commande, double x, double y, double z, int ticksRestants) {}
public record Resultat(UUID joueur, String commande, Fin fin) {}
private final Map<UUID, Attente> attentes = new HashMap<>();
/** Démarre (ou remplace) l'attente d'un joueur. */
public void start(UUID joueur, String commande, double x, double y, double z, int ticks) {
attentes.put(joueur, new Attente(joueur, commande, x, y, z, Math.max(0, ticks)));
}
public boolean has(UUID joueur) {
return attentes.containsKey(joueur);
}
/** Retire l'attente (blessure, déconnexion). Renvoie la commande annulée ou null. */
public String cancel(UUID joueur) {
Attente a = attentes.remove(joueur);
return a == null ? null : a.commande();
}
public interface Positions {
/** Position actuelle du joueur, ou null s'il n'est plus là. */
double[] of(UUID joueur);
}
/** Avance d'un tick : renvoie les attentes terminées (prêtes ou annulées pour mouvement). */
public List<Resultat> tick(Positions positions) {
List<Resultat> out = new ArrayList<>();
for (Iterator<Map.Entry<UUID, Attente>> it = attentes.entrySet().iterator(); it.hasNext(); ) {
Map.Entry<UUID, Attente> e = it.next();
Attente a = e.getValue();
double[] p = positions.of(a.joueur());
if (p == null) {
it.remove();
continue;
}
double dx = p[0] - a.x(), dy = p[1] - a.y(), dz = p[2] - a.z();
if (dx * dx + dy * dy + dz * dz > TOLERANCE * TOLERANCE) {
it.remove();
out.add(new Resultat(a.joueur(), a.commande(), Fin.BOUGE));
} else if (a.ticksRestants() <= 1) {
it.remove();
out.add(new Resultat(a.joueur(), a.commande(), Fin.PRET));
} else {
e.setValue(new Attente(a.joueur(), a.commande(), a.x(), a.y(), a.z(), a.ticksRestants() - 1));
}
}
return out;
}
}
+2 -2
Voir le fichier
@@ -4,10 +4,10 @@ license="MIT"
[[mods]] [[mods]]
modId="gastineltpa" modId="gastineltpa"
version="1.0.0" version="1.1.0"
displayName="GastinelTpa" displayName="GastinelTpa"
authors="Théo Gastinel" authors="Théo Gastinel"
description='''Demandes de téléportation entre joueurs (/tpa, /tpahere, /tpaccept, /tpadeny). Mod côté serveur uniquement.''' description='''Demandes de téléportation entre joueurs (/tpa, /tpahere, /tpaccept, /tpadeny), /spawn, /rtp et /rtp spawn (blocs de commande). Mod côté serveur uniquement.'''
# Les clients n'ont pas besoin du mod : ne pas exiger sa présence côté client. # Les clients n'ont pas besoin du mod : ne pas exiger sa présence côté client.
displayTest="IGNORE_ALL_VERSION" displayTest="IGNORE_ALL_VERSION"
+85
Voir le fichier
@@ -0,0 +1,85 @@
package com.gastineltpa.core;
import org.junit.jupiter.api.Test;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicLong;
import static org.junit.jupiter.api.Assertions.*;
class SpawnRtpCoreTest {
@Test
void recharge() {
AtomicLong t = new AtomicLong(0);
Cooldowns c = new Cooldowns(t::get);
UUID a = UUID.randomUUID();
assertEquals(0, c.remaining(a, "spawn"));
c.start(a, "spawn", 60);
assertEquals(60, c.remaining(a, "spawn"));
assertEquals(0, c.remaining(a, "rtp"));
t.set(59_001);
assertEquals(1, c.remaining(a, "spawn"));
t.set(60_000);
assertEquals(0, c.remaining(a, "spawn"));
}
@Test
void attentePuisDepart() {
Warmups w = new Warmups();
UUID a = UUID.randomUUID();
w.start(a, "spawn", 0, 64, 0, 3);
assertTrue(w.tick(id -> new double[]{0, 64, 0}).isEmpty());
assertTrue(w.tick(id -> new double[]{0.2, 64, 0}).isEmpty());
List<Warmups.Resultat> r = w.tick(id -> new double[]{0, 64, 0});
assertEquals(Warmups.Fin.PRET, r.get(0).fin());
assertFalse(w.has(a));
}
@Test
void attenteAnnuleeSiMouvementOuBlessure() {
Warmups w = new Warmups();
UUID a = UUID.randomUUID();
w.start(a, "rtp", 0, 64, 0, 60);
assertEquals(Warmups.Fin.BOUGE, w.tick(id -> new double[]{1, 64, 0}).get(0).fin());
w.start(a, "rtp", 0, 64, 0, 60);
assertEquals("rtp", w.cancel(a));
assertNull(w.cancel(a));
}
@Test
void zoneEtDisque() {
RtpLogic.Zone z = new RtpLogic.Zone(-100, 100, -100, 100, 0, 0, 50);
assertTrue(z.contient(30, 30));
assertFalse(z.contient(60, 60));
Random r = new Random(1);
for (int i = 0; i < 200; i++) {
int[] p = z.tirer(r);
assertNotNull(p);
assertTrue(z.contient(p[0], p[1]));
}
assertNull(new RtpLogic.Zone(1, 0, 0, 0, 0, 0, 0).tirer(r));
}
@Test
void tirageParmiLesMeilleurs() {
List<RtpLogic.Spot> s = List.of(new RtpLogic.Spot(0, 0, 0, 9, "a"), new RtpLogic.Spot(1, 0, 0, 1, "b"),
new RtpLogic.Spot(2, 0, 0, 5, "c"));
List<RtpLogic.Spot> top = RtpLogic.top(s, 2);
assertEquals(List.of(9.0, 5.0), top.stream().map(RtpLogic.Spot::score).toList());
Random r = new Random(2);
int a = 0;
for (int i = 0; i < 1400; i++) if (RtpLogic.tirerPondere(top, r).biome().equals("a")) a++;
assertTrue(a > 800 && a < 1000, "≈ 9/14 attendu, obtenu " + a);
assertNull(RtpLogic.tirerPondere(List.of(), r));
}
@Test
void blocsDangereux() {
assertTrue(RtpLogic.dangereux("minecraft:cactus"));
assertTrue(RtpLogic.dangereux("minecraft:sweet_berry_bush"));
assertFalse(RtpLogic.dangereux("minecraft:grass_block"));
}
}