P3.2 (partie Tower) : nouveau controle tower (OBSERVE par defaut)
- Pilier monte plus vite que le saut vanilla. Calcul vanilla (saut 0,42, v = (v - 0,08) x 0,98) : +1 bloc au 3e tick, retombee sur le bloc au 9e ; noJumpDelay 10 ticks espace maintenu (LivingEntity, NeoForge 21.1.234). - Signal : poses dans la colonne du joueur, juste sous ses pieds, chaque bloc un cran au-dessus du precedent, joueur en montee, separees de moins de towerIntervalleMinTicks (6). Apres towerSerie (5) intervalles courts, CHAQUE pose rapide suivante donne des points, donc un verdict annulable en ENFORCE (pas de "signale une fois, le reste passe"). - Exemptions MONDE et MOUVEMENT (levitation, vol permis, elytres, riptide, vehicule, recul, teleportation, contraption, vaisseau Sable), TPS bas. - Le scaffold horizontal n'est pas couvert (face cachee / AirPlace : deja interaction-bloc). - Tests : TowerP3Test (6). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
f52587ae62
révision
b6aecade29
9 fichiers modifiés
+203
-7
Aucun fichier ne correspond à votre recherche
@@ -523,16 +523,29 @@ public final class Garde {
|
||||
}
|
||||
|
||||
/** 0.5 (P2.4) : bloc posé par ce joueur. Vrai si la pose doit être annulée (ENFORCE, palier SETBACK ou plus). */
|
||||
public static boolean noterPose(ServerPlayer p) {
|
||||
public static boolean noterPose(ServerPlayer p, BlockPos pos) {
|
||||
if (!surThreadServeur(p)) return false;
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, pose annulée (C4)
|
||||
if (estExempteManuellement(p.getUUID())) return false;
|
||||
if (CONFIG.mode(Controle.FAST_PLACE) == Mode.OFF) return false;
|
||||
int tick = p.server.getTickCount();
|
||||
boolean annulerTower = false;
|
||||
if (CONFIG.mode(Controle.TOWER) != Mode.OFF) { // 0.5 (P3.2)
|
||||
Marques m = marques(p.getUUID());
|
||||
double dy = m.oeilDernier != null && m.oeilAvant != null ? m.oeilDernier[1] - m.oeilAvant[1] : 0;
|
||||
List<Verdict> vt = MOTEUR.poseTower(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(),
|
||||
pos.getZ(), p.getX(), p.getY(), p.getZ(), dy);
|
||||
Sanction st = traiter(p, vt);
|
||||
if (st == Sanction.EXPULSION) {
|
||||
appliquerSanctionMouvement(p, st, vt);
|
||||
return true;
|
||||
}
|
||||
annulerTower = Cablage.sanctionDeMouvement(st);
|
||||
}
|
||||
if (CONFIG.mode(Controle.FAST_PLACE) == Mode.OFF) return annulerTower;
|
||||
List<Verdict> v = MOTEUR.poseBloc(p.getUUID(), tick * 50L, tick, etat(p, true));
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
return Cablage.sanctionDeMouvement(s);
|
||||
return annulerTower || Cablage.sanctionDeMouvement(s);
|
||||
}
|
||||
|
||||
/** 0.5 (P2.10) : une face du bloc touche l'air ou un fluide (minerai visible sans x-ray). */
|
||||
|
||||
@@ -174,7 +174,7 @@ public final class GardeEvents {
|
||||
public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) {
|
||||
if (event.getLevel().isClientSide()) return;
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.noterPose(p)) event.setCanceled(true);
|
||||
if (Garde.noterPose(p, event.getPos())) event.setCanceled(true);
|
||||
}
|
||||
|
||||
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
|
||||
|
||||
@@ -38,7 +38,7 @@ public final class GardeSpec {
|
||||
private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE, INTER_MARGE;
|
||||
private static final ModConfigSpec.IntValue INTER_SERIE, TOTEM_ECHANT, TOTEM_ECART, TOTEM_REG_MAX;
|
||||
// 0.5 (P3)
|
||||
private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE, CRISTAL_DELAI, CRISTAL_SERIE;
|
||||
private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE, CRISTAL_DELAI, CRISTAL_SERIE, TOWER_INTERVALLE, TOWER_SERIE;
|
||||
|
||||
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
|
||||
private static final ModConfigSpec.IntValue CIBLES_MAX;
|
||||
@@ -334,6 +334,11 @@ public final class GardeSpec {
|
||||
.defineInRange("cristalDelaiMinTicks", 2, 1, 10);
|
||||
CRISTAL_SERIE = b.comment("Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter.")
|
||||
.defineInRange("cristalSerieMin", 6, 1, 10);
|
||||
TOWER_INTERVALLE = b.comment("0.5 (P3.2) tower : intervalle (ticks) entre deux poses en pilier sous les pieds sous lequel il est court.",
|
||||
"Vanilla : saut + retombée sur le bloc = 9 ticks, 10 espace maintenu ; le module Tower pose toutes les 2 à 4 ticks.")
|
||||
.defineInRange("towerIntervalleMinTicks", 6, 2, 9);
|
||||
TOWER_SERIE = b.comment("Tower : intervalles courts de suite avant que chaque pose rapide suivante compte (et soit annulable en ENFORCE).")
|
||||
.defineInRange("towerSerie", 5, 1, 50);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 (P2.10) x-ray statistique : alerte seulement, jamais de setback ni d'expulsion (même en ENFORCE).").push("xray");
|
||||
@@ -541,6 +546,8 @@ public final class GardeSpec {
|
||||
c.nukerSerieMin = NUKER_SERIE.get();
|
||||
c.cristalDelaiMinTicks = CRISTAL_DELAI.get();
|
||||
c.cristalSerieMin = CRISTAL_SERIE.get();
|
||||
c.towerIntervalleMinTicks = TOWER_INTERVALLE.get();
|
||||
c.towerSerie = TOWER_SERIE.get();
|
||||
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
|
||||
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
|
||||
c.graceReculTicks = GRACE_RECUL.get();
|
||||
|
||||
@@ -49,7 +49,9 @@ public enum Controle {
|
||||
/** 0.5 (P3.3) : plusieurs blocs cassés dans le même tick serveur, en série (Nuker). */
|
||||
NUKER("nuker"),
|
||||
/** 0.5 (P3.1) : cristaux de l'End frappés en série dès leur apparition (AutoCrystal / CrystalAura). */
|
||||
AUTO_CRISTAL("auto-cristal");
|
||||
AUTO_CRISTAL("auto-cristal"),
|
||||
/** 0.5 (P3.2) : pilier monté plus vite que le saut vanilla, blocs posés sous les pieds (Scaffold Tower). */
|
||||
TOWER("tower");
|
||||
|
||||
private final String id;
|
||||
|
||||
@@ -79,7 +81,7 @@ public enum Controle {
|
||||
// 0.5 : nouveaux contrôles P1 au plafond « faible » tant qu'ils n'ont pas été validés en jeu.
|
||||
case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM,
|
||||
NO_SLOW, FAST_BREAK, FAST_PLACE, INTERACTION_BLOC, AUTO_TOTEM_REGULIER,
|
||||
JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL -> 2; // 0.5 (P2) : idem
|
||||
JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL, TOWER -> 2; // 0.5 (P2) : idem
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -234,6 +234,10 @@ public final class GardeConfig {
|
||||
public int cristalDelaiMinTicks = 2;
|
||||
/** Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter. */
|
||||
public int cristalSerieMin = 6;
|
||||
/** Tower : intervalle (ticks) entre deux poses en pilier sous lequel il est court (vanilla : 9 à 10 au mieux). */
|
||||
public int towerIntervalleMinTicks = 6;
|
||||
/** Tower : intervalles courts de suite avant que chaque pose rapide suivante compte. */
|
||||
public int towerSerie = 5;
|
||||
|
||||
// --- 0.5 (P1.13, section [diagnostic]) : journal seulement, jamais de sanction ---
|
||||
/** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */
|
||||
|
||||
@@ -586,6 +586,28 @@ public final class Moteur {
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P3.2) : bloc posé, pour le tower. Exemptions MONDE et MOUVEMENT (lévitation, vol permis, élytres, riptide,
|
||||
* véhicule, recul, téléportation…) : une montée qui ne vient pas du saut n'est pas mesurée.
|
||||
*/
|
||||
public List<Verdict> poseTower(UUID joueur, long nowMs, long tick, EtatJoueur etat, int bx, int by, int bz,
|
||||
double px, double py, double pz, double dy) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.TOWER) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||
Exemptions.Resultat exM = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
|
||||
if (ex.exempt() || exM.exempt() || etat.tps() < cfg.tpsLag) {
|
||||
s.tower.vider();
|
||||
return List.of();
|
||||
}
|
||||
double pts = s.tower.pose(tick, bx, by, bz, px, py, pz, dy, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.TOWER, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"pilier : pose a %d tick(s) de la precedente (min %d), %d intervalles courts de suite",
|
||||
s.tower.dernierIntervalle(), cfg.towerIntervalleMinTicks, s.tower.courts()));
|
||||
return v;
|
||||
}
|
||||
|
||||
/** Un bloc vient d'être posé par le joueur (BlockEvent.EntityPlaceEvent) : fast-place. */
|
||||
public List<Verdict> poseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_PLACE) == Mode.OFF) return List.of();
|
||||
|
||||
@@ -85,6 +85,8 @@ public final class Suivi {
|
||||
public final Nuker nuker = new Nuker();
|
||||
/** 0.5 (P3.1) : auto-cristal. */
|
||||
public final AutoCristal autoCristal = new AutoCristal();
|
||||
/** 0.5 (P3.2) : tower. */
|
||||
public final Tower tower = new Tower();
|
||||
/** 0.5 (P1.6) : déploiements d'élytres répétés. */
|
||||
public final DeploiementsElytres deploiements = new DeploiementsElytres();
|
||||
/** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P3.2, partie « Tower » du Scaffold) : montée en pilier plus rapide que le saut vanilla. Calcul vanilla 1.21.1
|
||||
* (saut 0,42, puis v = (v − 0,08) × 0,98 par tick) : le joueur dépasse +1 bloc au 3e tick, retombe sur le bloc posé
|
||||
* au 9e ; espace maintenu, {@code noJumpDelay} impose de toute façon 10 ticks entre deux sauts (LivingEntity, sources
|
||||
* NeoForge 21.1.234). Un pilier honnête monte donc d'un bloc toutes les 9 à 10 ticks au mieux (Saut amélioré : plus
|
||||
* lent, le saut est plus haut). Le module Tower pose un bloc toutes les 2 à 4 ticks.
|
||||
*
|
||||
* Signal : poses « en pilier » (bloc dans la colonne du joueur, juste sous ses pieds, chaque bloc un cran au-dessus du
|
||||
* précédent, joueur en montée) séparées de moins de {@link GardeConfig#towerIntervalleMinTicks} (6) ticks. Après
|
||||
* {@link GardeConfig#towerSerie} (5) intervalles courts de suite, <b>chaque</b> pose rapide suivante donne des points
|
||||
* (donc un verdict, annulable en ENFORCE) : pas de « signalé une fois, le reste passe ». Toute autre pose, une pause
|
||||
* ou un intervalle normal remet la chaîne à zéro. Le scaffold horizontal (pont) n'est pas couvert : face cachée et
|
||||
* AirPlace le sont par interaction-bloc. OBSERVE par défaut.
|
||||
*/
|
||||
public final class Tower {
|
||||
|
||||
private long dernierTick = Long.MIN_VALUE;
|
||||
private int dernierY;
|
||||
private int courts;
|
||||
private int dernierIntervalle;
|
||||
|
||||
/**
|
||||
* @param bx, by, bz bloc posé
|
||||
* @param px, py, pz position (pieds) du joueur
|
||||
* @param dy déplacement vertical du dernier paquet de mouvement (montée > 0)
|
||||
* @return points d'infraction
|
||||
*/
|
||||
public double pose(long tick, int bx, int by, int bz, double px, double py, double pz, double dy, GardeConfig cfg) {
|
||||
boolean pilier = (int) Math.floor(px) == bx && (int) Math.floor(pz) == bz && py >= by + 1 - 0.01
|
||||
&& py < by + 2.5 && dy > 0;
|
||||
if (!pilier) {
|
||||
vider();
|
||||
return 0;
|
||||
}
|
||||
boolean suite = dernierTick != Long.MIN_VALUE && by == dernierY + 1 && tick > dernierTick;
|
||||
long ecart = suite ? tick - dernierTick : Long.MAX_VALUE;
|
||||
dernierTick = tick;
|
||||
dernierY = by;
|
||||
if (!suite) {
|
||||
courts = 0;
|
||||
return 0;
|
||||
}
|
||||
dernierIntervalle = (int) Math.min(Integer.MAX_VALUE, ecart);
|
||||
if (ecart >= Math.max(1, cfg.towerIntervalleMinTicks)) {
|
||||
courts = 0;
|
||||
return 0;
|
||||
}
|
||||
courts++;
|
||||
return courts >= Math.max(1, cfg.towerSerie) ? 1.5 : 0;
|
||||
}
|
||||
|
||||
public int dernierIntervalle() {
|
||||
return dernierIntervalle;
|
||||
}
|
||||
|
||||
public int courts() {
|
||||
return courts;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
dernierTick = Long.MIN_VALUE;
|
||||
courts = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P3.2 : tower (pilier monté plus vite que le saut vanilla). */
|
||||
class TowerP3Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/** n poses en pilier (x = 10, z = 20), une toutes les {@code pas} ticks ; renvoie le nombre de verdicts. */
|
||||
private int pilier(Moteur m, EtatJoueur etat, int n, int pas) {
|
||||
int verdicts = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
long t = 100 + (long) i * pas;
|
||||
int by = 64 + i;
|
||||
for (Verdict v : m.poseTower(joueur, t * 50L, t, etat, 10, by, 20, 10.5, by + 1.1, 20.5, 0.2)) {
|
||||
if (v.controle() == Controle.TOWER) verdicts++;
|
||||
}
|
||||
}
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.TOWER));
|
||||
assertEquals(Controle.TOWER, Controle.parse("tower"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void towerToutesLesTroisTicksVuEtChaquePoseCompte() {
|
||||
// 5 intervalles courts pour armer, puis chaque pose rapide donne un verdict (annulable en ENFORCE).
|
||||
assertEquals(20 - 1 - cfg.towerSerie + 1, pilier(new Moteur(cfg), EtatJoueur.normal(), 20, 3));
|
||||
}
|
||||
|
||||
@Test
|
||||
void pilierVanillaJamaisVu() {
|
||||
assertEquals(0, pilier(new Moteur(cfg), EtatJoueur.normal(), 100, 9));
|
||||
assertEquals(0, pilier(new Moteur(cfg), EtatJoueur.normal(), 100, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
void poseHorsColonneOuSansMonteeNonMesuree() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
int n = 0;
|
||||
for (int i = 0; i < 30; i++) {
|
||||
long t = 100 + i * 2L;
|
||||
// pont horizontal : bloc devant, joueur qui ne monte pas
|
||||
n += m.poseTower(joueur, t * 50L, t, EtatJoueur.normal(), 10 + i, 63, 20, 10.5 + i, 64, 20.5, 0).size();
|
||||
}
|
||||
assertEquals(0, n);
|
||||
}
|
||||
|
||||
@Test
|
||||
void levitationEtCreatifExemptes() {
|
||||
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
|
||||
EtatJoueur.builder().levitation(true).build(), EtatJoueur.builder().peutVoler(true).build()}) {
|
||||
assertEquals(0, pilier(new Moteur(cfg), e, 30, 2), e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void enforceChaquePoseRapideAtteintLePalier() {
|
||||
cfg.mode(Controle.TOWER, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
boolean setback = false;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
long t = 100 + i * 2L;
|
||||
int by = 64 + i;
|
||||
for (Verdict v : m.poseTower(joueur, t * 50L, t, EtatJoueur.normal(), 10, by, 20, 10.5, by + 1.1, 20.5, 0.2)) {
|
||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true;
|
||||
}
|
||||
}
|
||||
assertTrue(setback);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur