GastinelGarde 0.2.0 : phase 2 (no-fall corrige en enforce, vitesse horizontale, vol vertical), 90 tests
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
b7e57250ff
révision
a70809df6c
15 fichiers modifiés
+750
-11
Aucun fichier ne correspond à votre recherche
+123
@@ -0,0 +1,123 @@
|
||||
# GastinelGarde
|
||||
|
||||
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions :
|
||||
`../PLAN-GASTINELGARDE.md`. Version **0.2.0** : phases 0, 1 et 2 du plan.
|
||||
|
||||
**État** : compilé, 90 tests JUnit verts (cœur pur, commandes, configuration, application réelle des mixins).
|
||||
**Jamais testé en jeu.** Tous les contrôles démarrent en `OBSERVE` (journal et message aux ops, aucune sanction).
|
||||
Il n'y a jamais de bannissement automatique.
|
||||
|
||||
## Architecture
|
||||
|
||||
| Couche | Contenu |
|
||||
|---|---|
|
||||
| `core/` (Java pur, sans Minecraft, testé en JUnit) | `Moteur`, contrôles, points d'infraction (`VlCompteur`, décroissance), `Paliers`, `Exemptions`, `TraceLigne` / `TraceFichier` |
|
||||
| `Garde`, `GardeEvents`, `GardeCommands`, `GardeSpec` | lecture de l'état du serveur, événements NeoForge, commandes, configuration |
|
||||
| `mixin/` | `MovePacketMixin` (lecture seule : débit des paquets, position acceptée, marque de téléportation), `RiptideMoveMixin` (tolérance riptide, reprise de GastinelClaims) |
|
||||
|
||||
Les décisions de langage (Java, Rust seulement après benchmark) sont à la section 8 du plan.
|
||||
L'interface du cœur ne contient aucun type Minecraft (tableaux, primitifs, enregistrements) pour pouvoir
|
||||
porter un module plus tard.
|
||||
|
||||
## Contrôles (phase 1)
|
||||
|
||||
| Id | Idée | Seuils par défaut |
|
||||
|---|---|---|
|
||||
| `killaura-angle` | angle entre le regard et la silhouette de la cible | 60° d'excédent |
|
||||
| `killaura-cibles` | entités différentes touchées | plus de 3 en 1 s |
|
||||
| `cadence` | coups par seconde | plus de 20 sur 2 s consécutives |
|
||||
| `regularite` | intervalles quasi identiques à cadence rapide | écart type < 12 ms et moyenne < 150 ms |
|
||||
| `attaque-impossible` | coup en mangeant ou en buvant, ou cible non visible | sans seuil |
|
||||
| `timer` | paquets de mouvement par seconde | plus de 22 sur 3 s consécutives |
|
||||
|
||||
### Contrôles de mouvement (phase 2, version 0.2.0)
|
||||
|
||||
| Id | Idée | Détail |
|
||||
|---|---|---|
|
||||
| `no-fall` | le client déclare « au sol » en pleine chute sans bloc dessous | **Corrige, ne punit pas** : en `ENFORCE`, le serveur remplace le drapeau transmis aux dégâts de chute (mixin `@ModifyArg` sur `doCheckFallDamage`). En `OBSERVE`, rien n'est modifié. Faible poids (0,5 point). |
|
||||
| `vitesse` | déplacement horizontal supérieur au maximum attendu | Tampon d'excès sur 20 ticks (1,5 bloc par défaut). Bornes : marche 0,23, course 0,30, saut en courant 0,42 bloc par tick, modulées par Vitesse et Lenteur. **Valeurs de départ généreuses, à resserrer avec les traces.** |
|
||||
| `vol` | en l'air, la vitesse verticale ne suit pas la gravité | Modèle `vy suivante = (vy − 0,08) × 0,98`, tolérance 0,05, plus de 10 ticks anormaux consécutifs. Détecte le flottement, la montée constante et le plané lent. |
|
||||
|
||||
Exemptions propres au mouvement : eau, lave, échelle, nage, vol créatif, toile, neige poudreuse, baie sucrée, slime,
|
||||
lit (milieu spécial) ; glace, âmes, miel (friction ou facteur de vitesse différents) ; plus toutes les exemptions
|
||||
communes ci-dessous. **Non gérés pour l'instant** (fausses alertes possibles en `OBSERVE`) : charge de vent
|
||||
(Wind Charge), propulsion par des mods tiers, vitesses imposées par des blocs de commande.
|
||||
|
||||
Les temps de combat sont ceux du serveur (tick × 50 ms) : la régularité est donc mesurée au tick, ce qui rend
|
||||
l'écart type de 12 ms équivalent à « exactement constant ». Une arme à cadence fixe lente n'est pas suspecte.
|
||||
|
||||
### Exemptions (une seule fonction : `core/Exemptions`)
|
||||
|
||||
Créatif, spectateur ; riptide (trident Impulsion en main et 2 s après) ; élytres ; lévitation, chute lente ;
|
||||
véhicule ; contraption Create / Aeronautics à moins de 3 blocs (détection par préfixe de nom de classe, **à valider
|
||||
sur le serveur réel**) ; 2 s après une téléportation, un recul ou un dégât ; gel du serveur (tick de plus de
|
||||
250 ms, 5 s de grâce). Serveur sous 18 TPS ou ping de plus de 250 ms : seuils × 1,5.
|
||||
|
||||
## Sanctions
|
||||
|
||||
| Palier (points d'un contrôle) | OBSERVE | ENFORCE |
|
||||
|---|---|---|
|
||||
| au-dessus de 0 | journal | journal |
|
||||
| 5 | alerte aux ops | alerte aux ops |
|
||||
| 10 | alerte | coup annulé / retour à la dernière position valide |
|
||||
| 20 | alerte | expulsion |
|
||||
|
||||
Plafond configurable (`sanctionMax`). Les points décroissent de 0,5 par seconde.
|
||||
|
||||
## Commandes (ops, niveau 2)
|
||||
|
||||
```
|
||||
/garde état
|
||||
/garde status [joueur] modes, ou points d'infraction d'un joueur
|
||||
/garde alertes on|off messages de l'anti-triche pour toi
|
||||
/garde mode <contrôle> off|observe|enforce (écrit dans la configuration)
|
||||
/garde exempter <joueur> <minutes>
|
||||
/garde traces on|off enregistreur (jusqu'au redémarrage)
|
||||
/garde reload
|
||||
```
|
||||
|
||||
## Fichiers
|
||||
|
||||
- Configuration : `config/gastinelgarde-server.toml` (rechargée à chaud, plus `/garde reload`).
|
||||
- Journal : `logs/gastinelgarde.log` (une ligne par infraction : contrôle, points, exemptions actives).
|
||||
- Traces : `gastinelgarde-traces/trace-AAAA-MM-JJ.jsonl`. **Enregistrement continu pour tous** (décision T7 de
|
||||
Théo). Ce sont des positions de joueurs, donc des données personnelles : conservation 7 jours et 1 Go au
|
||||
maximum par défaut (`[traces]` dans la configuration). Ordre de grandeur : 20 lignes par seconde et par
|
||||
joueur, environ 150 octets par ligne, donc environ 10 Mo par heure et par joueur connecté.
|
||||
|
||||
## Construire et déployer
|
||||
|
||||
```
|
||||
sh build-sur-cornafserver.sh # sur cornafserver, conteneur JDK 21 jetable
|
||||
.\gradlew.bat build # ou sur le PC (JDK 21) : build/libs/gastinelgarde-neoforge-1.21.1-0.2.0.jar
|
||||
bash ../deployer-garde-0-2-0.sh # sur cornafserver, par Théo (non lancé)
|
||||
```
|
||||
|
||||
### À vérifier en jeu (jamais fait)
|
||||
|
||||
1. `/garde status` répond, tous les contrôles en OBSERVE.
|
||||
2. Marcher, sprinter, nager, prendre une perle : aucune alerte.
|
||||
3. Avec ton client de triche : killaura (`killaura-angle`, `killaura-cibles`, `cadence`), timer, speed (`vitesse`),
|
||||
fly (`vol`) et no-fall lèvent des infractions dans `logs/gastinelgarde.log`.
|
||||
Honnêtement, essayer aussi : sauts en courant, chute, glace, échelle, eau, slime, Wind Charge, élytres avec
|
||||
fusée, riptide, perle. Chaque ligne du journal indique les exemptions actives.
|
||||
4. Riptide : plus de retour en arrière (le mixin est repris de GastinelClaims 1.1.6).
|
||||
5. Create Aeronautics : monter dans une contraption, se battre dessus. Aucune fausse alerte, sinon relever les
|
||||
noms de classe des entités et compléter `prefixesContraption`.
|
||||
6. Lancer une session honnête (marche, combat, riptide, élytres, bateau volant) pour amorcer le corpus de traces.
|
||||
|
||||
### Riptide : GastinelClaims 1.1.6 contient le même mixin
|
||||
|
||||
Décision T6 : le mixin riptide vit désormais dans GastinelGarde. Tant que les deux mods sont présents, le seuil est
|
||||
relevé deux fois au même maximum (sans danger). À faire plus tard : une 1.1.7 de GastinelClaims sans
|
||||
`RiptideMoveMixin` ni `RiptideTolerance` (non fait : le code de GastinelClaims 1.1.2 à 1.1.6 n'est pas commité).
|
||||
|
||||
## Limites connues
|
||||
|
||||
- Phase 3 non commencée : élytres, débogage d'AntiXray, heuristique de minage.
|
||||
- Phase 2 jamais essayée sur de vrais mouvements : les bornes de vitesse et le modèle de vol viennent des
|
||||
formules vanilla, pas de mesures. Les traces enregistrées permettront de les ajuster avant tout `ENFORCE`.
|
||||
- La grâce « gel du serveur » se base sur la durée d'un tick (> 250 ms), pas sur le message vanilla « Can't keep up ».
|
||||
- `online-mode=false` : un tricheur expulsé peut revenir sous un autre pseudo de la whitelist.
|
||||
- Le contrôle `attaque-impossible` ne couvre que les cas à courte portée : vanilla refuse déjà les coups à plus de
|
||||
3 blocs sans ligne de vue.
|
||||
@@ -1,7 +1,7 @@
|
||||
org.gradle.jvmargs=-Xmx2G
|
||||
org.gradle.parallel=true
|
||||
|
||||
mod_version=0.1.0
|
||||
mod_version=0.2.0
|
||||
mod_group_id=com.gastinelgarde
|
||||
mod_id=gastinelgarde
|
||||
|
||||
|
||||
@@ -1,7 +1,10 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import com.gastinelgarde.core.Controle;
|
||||
import com.gastinelgarde.core.EtatJoueur;
|
||||
import com.gastinelgarde.core.EtatMouvement;
|
||||
import com.gastinelgarde.core.GardeConfig;
|
||||
import com.gastinelgarde.core.Mode;
|
||||
import com.gastinelgarde.core.Moteur;
|
||||
import com.gastinelgarde.core.Sanction;
|
||||
import com.gastinelgarde.core.Suivi;
|
||||
@@ -21,7 +24,14 @@ import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
import net.minecraft.ChatFormatting;
|
||||
import net.minecraft.core.BlockPos;
|
||||
import net.minecraft.core.Holder;
|
||||
import net.minecraft.network.chat.Component;
|
||||
import net.minecraft.tags.BlockTags;
|
||||
import net.minecraft.world.effect.MobEffect;
|
||||
import net.minecraft.world.effect.MobEffectInstance;
|
||||
import net.minecraft.world.level.block.Blocks;
|
||||
import net.minecraft.world.level.block.state.BlockState;
|
||||
import net.minecraft.server.MinecraftServer;
|
||||
import net.minecraft.server.level.ServerPlayer;
|
||||
import net.minecraft.world.effect.MobEffects;
|
||||
@@ -50,6 +60,12 @@ public final class Garde {
|
||||
long exemptJusquaMs = 0;
|
||||
double dernierX, dernierY, dernierZ;
|
||||
boolean aDernierePosition;
|
||||
// Mouvement (phase 2)
|
||||
int mouvementTick = Integer.MIN_VALUE;
|
||||
double mouvementX, mouvementY, mouvementZ;
|
||||
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
|
||||
int contraptionTick = Integer.MIN_VALUE;
|
||||
boolean contraptionProche;
|
||||
}
|
||||
|
||||
private static final GardeConfig CONFIG = new GardeConfig();
|
||||
@@ -194,7 +210,7 @@ public final class Garde {
|
||||
.levitation(p.hasEffect(MobEffects.LEVITATION))
|
||||
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
|
||||
.enVehicule(p.isPassenger())
|
||||
.pocheContraption(chercherContraption && pocheContraption(p))
|
||||
.pocheContraption(chercherContraption && pocheContraptionEnCache(p, m, tick))
|
||||
.utiliseObjet(mange)
|
||||
.ticksDepuisTeleport(depuis(tick, m.teleportTick))
|
||||
.ticksDepuisRecul(depuis(tick, m.reculTick))
|
||||
@@ -213,6 +229,15 @@ public final class Garde {
|
||||
return stack.is(Items.TRIDENT) && EnchantmentHelper.getTridentSpinAttackStrength(stack, joueur) > 0.0F;
|
||||
}
|
||||
|
||||
/** La détection est refaite au plus toutes les 10 ticks par joueur. */
|
||||
private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
|
||||
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) {
|
||||
m.contraptionProche = pocheContraption(p);
|
||||
m.contraptionTick = tick;
|
||||
}
|
||||
return m.contraptionProche;
|
||||
}
|
||||
|
||||
/** Une entité de contraption (Create, Aeronautics…) est-elle toute proche ? Détection par nom de classe. */
|
||||
private static boolean pocheContraption(Player p) {
|
||||
int dist = GardeSpec.distanceContraption();
|
||||
@@ -238,11 +263,15 @@ public final class Garde {
|
||||
public static Sanction traiter(ServerPlayer p, List<Verdict> verdicts) {
|
||||
if (verdicts.isEmpty()) return Sanction.AUCUNE;
|
||||
marques(p.getUUID()).dernierVerdictTick = p.server.getTickCount();
|
||||
long maintenant = System.currentTimeMillis();
|
||||
Suivi suivi = MOTEUR.suivi(p.getUUID());
|
||||
for (Verdict v : verdicts) {
|
||||
String ligne = String.format("%s %s mode=%s vl=%.1f (+%.1f) palier=%s applique=%s %s exemptions=%s",
|
||||
p.getGameProfile().getName(), v.controle().id(), v.mode(), v.vl(), v.points(),
|
||||
v.palier(), v.applicable(), v.details(), v.exemptions());
|
||||
ecrireJournal(ligne);
|
||||
if (suivi.autoriserJournal(v.controle(), maintenant, 1000)) { // au plus une ligne par seconde et par contrôle
|
||||
String ligne = String.format("%s %s mode=%s vl=%.1f (+%.1f) palier=%s applique=%s %s exemptions=%s",
|
||||
p.getGameProfile().getName(), v.controle().id(), v.mode(), v.vl(), v.points(),
|
||||
v.palier(), v.applicable(), v.details(), v.exemptions());
|
||||
ecrireJournal(ligne);
|
||||
}
|
||||
if (v.notifier()) alerterOps(p, v);
|
||||
}
|
||||
return Verdict.pire(verdicts);
|
||||
@@ -295,6 +324,25 @@ public final class Garde {
|
||||
public static void apresMouvement(ServerPlayer p) {
|
||||
int tick = p.server.getTickCount();
|
||||
Marques m = marques(p.getUUID());
|
||||
boolean solServeur = auSolServeur(p);
|
||||
|
||||
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
|
||||
if (mouvementControlesActifs() && !estExempteManuellement(p.getUUID()) && m.mouvementTick != Integer.MIN_VALUE) {
|
||||
double dx = p.getX() - m.mouvementX;
|
||||
double dz = p.getZ() - m.mouvementZ;
|
||||
EtatMouvement em = new EtatMouvement(Math.sqrt(dx * dx + dz * dz), p.getY() - m.mouvementY,
|
||||
tick - m.mouvementTick, p.onGround(), solServeur, p.isSprinting(), p.isShiftKeyDown(),
|
||||
p.isUsingItem(), niveau(p, MobEffects.MOVEMENT_SPEED), niveau(p, MobEffects.MOVEMENT_SLOWDOWN),
|
||||
milieuSpecial(p), frictionAnormale(p));
|
||||
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etat(p, true), em);
|
||||
Sanction s = traiter(p, v);
|
||||
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
|
||||
}
|
||||
m.mouvementTick = tick;
|
||||
m.mouvementX = p.getX();
|
||||
m.mouvementY = p.getY();
|
||||
m.mouvementZ = p.getZ();
|
||||
|
||||
if (m.dernierVerdictTick != tick) {
|
||||
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
|
||||
p.level().dimension().location().toString());
|
||||
@@ -308,12 +356,53 @@ public final class Garde {
|
||||
m.dernierY = p.getY();
|
||||
m.dernierZ = p.getZ();
|
||||
m.aDernierePosition = true;
|
||||
boolean solServeur = !p.level().noCollision(p, p.getBoundingBox().move(0.0, -0.05, 0.0));
|
||||
tracer(new TraceLigne(tick, p.getGameProfile().getName(), "move", p.getX(), p.getY(), p.getZ(),
|
||||
vx, vy, vz, p.onGround(), solServeur, TraceLigne.masque(etat(p, false)), -1, Double.NaN, null));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Drapeau « au sol » à donner aux dégâts de chute (appelé par le mixin). En OBSERVE ou hors exemption
|
||||
* inapplicable, c'est celui du client : comportement vanilla.
|
||||
*/
|
||||
public static boolean auSolPourChute(ServerPlayer p, boolean auSolClient) {
|
||||
if (!auSolClient) return false;
|
||||
if (CONFIG.mode(Controle.NO_FALL) != Mode.ENFORCE) return auSolClient;
|
||||
if (estExempteManuellement(p.getUUID())) return auSolClient;
|
||||
return MOTEUR.auSolPourDegatsDeChute(etat(p, true), auSolClient, auSolServeur(p));
|
||||
}
|
||||
|
||||
private static boolean mouvementControlesActifs() {
|
||||
return CONFIG.mode(Controle.NO_FALL) != Mode.OFF || CONFIG.mode(Controle.VITESSE) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.VOL) != Mode.OFF;
|
||||
}
|
||||
|
||||
/** Bloc solide sous la boîte du joueur, vu par le serveur (0,05 bloc de marge). */
|
||||
private static boolean auSolServeur(ServerPlayer p) {
|
||||
return !p.level().noCollision(p, p.getBoundingBox().move(0.0, -0.05, 0.0));
|
||||
}
|
||||
|
||||
private static int niveau(ServerPlayer p, Holder<MobEffect> effet) {
|
||||
MobEffectInstance e = p.getEffect(effet);
|
||||
return e == null ? 0 : e.getAmplifier() + 1;
|
||||
}
|
||||
|
||||
/** Eau, lave, échelle, vol créatif, toile, neige poudreuse, miel, slime, lit : la vitesse et le vol vanilla ne s'appliquent pas. */
|
||||
private static boolean milieuSpecial(ServerPlayer p) {
|
||||
if (p.isInWater() || p.isInLava() || p.onClimbable() || p.isSwimming() || p.getAbilities().flying) return true;
|
||||
BlockPos pos = p.blockPosition();
|
||||
BlockState pied = p.level().getBlockState(pos);
|
||||
BlockState sous = p.level().getBlockState(pos.below());
|
||||
return pied.is(Blocks.COBWEB) || pied.is(Blocks.POWDER_SNOW) || pied.is(Blocks.SWEET_BERRY_BUSH)
|
||||
|| sous.is(Blocks.SLIME_BLOCK) || sous.is(BlockTags.BEDS);
|
||||
}
|
||||
|
||||
/** Glace, slime, âmes, miel : friction ou facteur de vitesse du bloc différents de la normale. */
|
||||
private static boolean frictionAnormale(ServerPlayer p) {
|
||||
BlockState sous = p.level().getBlockState(p.getBlockPosBelowThatAffectsMyMovement());
|
||||
return sous.getBlock().getFriction() != 0.6F || sous.getBlock().getSpeedFactor() != 1.0F;
|
||||
}
|
||||
|
||||
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
||||
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
|
||||
if (s == Sanction.EXPULSION) {
|
||||
|
||||
@@ -31,6 +31,8 @@ public final class GardeSpec {
|
||||
private static final ModConfigSpec.IntValue PAQUETS_PAR_SECONDE;
|
||||
private static final ModConfigSpec.IntValue TIMER_SECONDES;
|
||||
|
||||
private static final ModConfigSpec.DoubleValue EXCES_VITESSE;
|
||||
|
||||
private static final ModConfigSpec.IntValue GRACE_TELEPORT;
|
||||
private static final ModConfigSpec.IntValue GRACE_RECUL;
|
||||
private static final ModConfigSpec.IntValue GRACE_GEL;
|
||||
@@ -82,6 +84,12 @@ public final class GardeSpec {
|
||||
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
||||
b.pop();
|
||||
|
||||
b.push("mouvement");
|
||||
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
|
||||
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
|
||||
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
|
||||
b.pop();
|
||||
|
||||
b.push("exemptions");
|
||||
GRACE_TELEPORT = b.defineInRange("graceTeleportTicks", 40, 0, 600);
|
||||
GRACE_RECUL = b.defineInRange("graceReculTicks", 20, 0, 600);
|
||||
@@ -135,6 +143,7 @@ public final class GardeSpec {
|
||||
c.intervalleMoyenMaxMs = INTERVALLE_MOYEN_MAX.get();
|
||||
c.paquetsParSecondeMax = PAQUETS_PAR_SECONDE.get();
|
||||
c.timerSecondesSoutenues = TIMER_SECONDES.get();
|
||||
c.excesVitesseBlocs = EXCES_VITESSE.get();
|
||||
c.graceTeleportTicks = GRACE_TELEPORT.get();
|
||||
c.graceReculTicks = GRACE_RECUL.get();
|
||||
c.graceGelTicks = GRACE_GEL.get();
|
||||
|
||||
@@ -1,13 +1,16 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/** Les contrôles de la phase 1 (combat et cadence). Les phases 2 et 3 s'ajouteront ici. */
|
||||
/** Les contrôles : phase 1 (combat, cadence, timer) et phase 2 (no-fall, vitesse, vol). La phase 3 s'ajoutera. */
|
||||
public enum Controle {
|
||||
KILLAURA_ANGLE("killaura-angle"),
|
||||
KILLAURA_CIBLES("killaura-cibles"),
|
||||
CADENCE("cadence"),
|
||||
REGULARITE("regularite"),
|
||||
ATTAQUE_IMPOSSIBLE("attaque-impossible"),
|
||||
TIMER("timer");
|
||||
TIMER("timer"),
|
||||
NO_FALL("no-fall"),
|
||||
VITESSE("vitesse"),
|
||||
VOL("vol");
|
||||
|
||||
private final String id;
|
||||
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Un tick de mouvement d'un joueur, tel que le serveur l'a accepté (phase 2). Tout vient du serveur.
|
||||
*
|
||||
* @param dxz déplacement horizontal depuis le paquet précédent accepté (blocs)
|
||||
* @param dy déplacement vertical (blocs)
|
||||
* @param ticks nombre de ticks serveur écoulés depuis le paquet précédent (au moins 1)
|
||||
* @param auSolClient ce que le client déclare
|
||||
* @param auSolServeur bloc solide sous la boîte du joueur, vu par le serveur
|
||||
* @param sprint le joueur court
|
||||
* @param furtif le joueur est accroupi
|
||||
* @param ralentiParObjet utilise un objet (manger, bloquer, arc…) : ralenti
|
||||
* @param amplificateurVitesse niveau de l'effet Vitesse (0 si aucun, 1 = niveau I)
|
||||
* @param amplificateurLenteur niveau de l'effet Lenteur (0 si aucun)
|
||||
* @param milieuSpecial eau, lave, échelle, liane, toile, miel, neige poudreuse, colonne à bulles : le calcul
|
||||
* de vitesse ne s'applique pas
|
||||
* @param frictionAnormale glace, glace compacte, glace bleue, slime, âmes… : le calcul ne s'applique pas
|
||||
*/
|
||||
public record EtatMouvement(double dxz, double dy, int ticks, boolean auSolClient, boolean auSolServeur,
|
||||
boolean sprint, boolean furtif, boolean ralentiParObjet,
|
||||
int amplificateurVitesse, int amplificateurLenteur,
|
||||
boolean milieuSpecial, boolean frictionAnormale) {
|
||||
}
|
||||
@@ -37,6 +37,10 @@ public final class GardeConfig {
|
||||
public int paquetsParSecondeMax = 22;
|
||||
public int timerSecondesSoutenues = 3;
|
||||
|
||||
// --- Mouvement (phase 2) ---
|
||||
/** Total d'excès de vitesse horizontale (blocs) sur 20 ticks au-delà duquel on lève une infraction. */
|
||||
public double excesVitesseBlocs = 1.5;
|
||||
|
||||
// --- Exemptions ---
|
||||
public int graceTeleportTicks = 40;
|
||||
public int graceReculTicks = 20;
|
||||
|
||||
@@ -103,6 +103,49 @@ public final class Moteur {
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Un mouvement accepté par le serveur (phase 2) : no-fall (divergence), vitesse horizontale, vol.
|
||||
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
|
||||
*/
|
||||
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
|
||||
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
|
||||
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
|
||||
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
|
||||
if (!noFall && !vitesse && !vol) return List.of();
|
||||
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
|
||||
if (ex.exempt()) {
|
||||
s.vitesse.vider();
|
||||
s.vol.vider();
|
||||
return List.of();
|
||||
}
|
||||
List<Verdict> verdicts = new ArrayList<>(3);
|
||||
if (noFall) {
|
||||
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex,
|
||||
"au sol declare sans bloc dessous pendant une chute");
|
||||
}
|
||||
if (vitesse) {
|
||||
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
|
||||
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
|
||||
String.format(Locale.ROOT, "dxz=%.3f max=%.3f", m.dxz(), VitesseHorizontale.vitesseMax(m)));
|
||||
}
|
||||
if (vol) {
|
||||
double pts = s.vol.enregistrer(m, false);
|
||||
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
|
||||
}
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Drapeau « au sol » à donner aux dégâts de chute : celui du serveur en ENFORCE (sauf exemption), celui du
|
||||
* client sinon.
|
||||
*/
|
||||
public boolean auSolPourDegatsDeChute(EtatJoueur etat, boolean auSolClient, boolean auSolServeur) {
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
|
||||
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
|
||||
}
|
||||
|
||||
// --- Interne ----------------------------------------------------------------------------------------
|
||||
|
||||
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Contrôle 6 : no-fall. Le client déclare « au sol » et vanilla le croit, donc plus de dégâts de chute. Le serveur
|
||||
* calcule lui-même s'il y a un bloc sous le joueur.
|
||||
*
|
||||
* Principe du plan : on corrige, on ne punit pas. En {@code ENFORCE}, le drapeau transmis aux dégâts de chute est
|
||||
* remplacé par celui du serveur ; en {@code OBSERVE}, rien n'est modifié et la divergence est seulement journalisée.
|
||||
*/
|
||||
public final class NoFall {
|
||||
|
||||
/** Chute rapide minimale (blocs par tick, négatif) à partir de laquelle une divergence compte. */
|
||||
public static final double DY_CHUTE = -0.3;
|
||||
|
||||
private NoFall() { }
|
||||
|
||||
/**
|
||||
* Drapeau « au sol » à utiliser pour les dégâts de chute.
|
||||
*
|
||||
* @param exempt joueur exempté du mouvement (contraption, véhicule, riptide…) : on ne touche à rien
|
||||
*/
|
||||
public static boolean auSolEffectif(boolean auSolClient, boolean auSolServeur, boolean exempt, Mode mode) {
|
||||
if (mode != Mode.ENFORCE || exempt) return auSolClient;
|
||||
return auSolClient && auSolServeur;
|
||||
}
|
||||
|
||||
/**
|
||||
* Points d'infraction : le client déclare « au sol » pendant une chute rapide alors qu'aucun bloc n'est sous
|
||||
* lui. Faible volontairement (0,5) : le plan veut corriger sans punir au début.
|
||||
*/
|
||||
public static double points(EtatMouvement e) {
|
||||
if (e.auSolClient() && !e.auSolServeur() && e.dy() <= DY_CHUTE && !e.milieuSpecial()) return 0.5;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,8 @@ public final class Suivi {
|
||||
public final CiblesMultiples cibles = new CiblesMultiples();
|
||||
public final Cadence cadence = new Cadence();
|
||||
public final TimerPaquets timer = new TimerPaquets();
|
||||
public final VitesseHorizontale vitesse = new VitesseHorizontale();
|
||||
public final VolVertical vol = new VolVertical();
|
||||
|
||||
// Dernière position jugée valide (retour en arrière).
|
||||
private boolean positionValide;
|
||||
@@ -41,6 +43,8 @@ public final class Suivi {
|
||||
public float pitch() { return pitch; }
|
||||
public String dimension() { return dimension; }
|
||||
|
||||
private final Map<Controle, Long> dernierJournal = new EnumMap<>(Controle.class);
|
||||
|
||||
/** Vrai si une alerte peut partir maintenant pour ce contrôle (au plus une toutes les {@code delaiMs}). */
|
||||
boolean autoriserAlerte(Controle c, long nowMs, long delaiMs) {
|
||||
Long derniere = derniereAlerte.get(c);
|
||||
@@ -48,4 +52,12 @@ public final class Suivi {
|
||||
derniereAlerte.put(c, nowMs);
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Idem pour le journal : évite une ligne par tick pendant une chute ou une course. */
|
||||
public boolean autoriserJournal(Controle c, long nowMs, long delaiMs) {
|
||||
Long derniere = dernierJournal.get(c);
|
||||
if (derniere != null && nowMs - derniere < delaiMs) return false;
|
||||
dernierJournal.put(c, nowMs);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Contrôle 7 : vitesse horizontale. Un tampon d'excès sur 20 ticks plutôt qu'un seuil à chaque paquet (plan),
|
||||
* pour absorber les paquets groupés par le réseau.
|
||||
*
|
||||
* Les bornes sont volontairement généreuses (les valeurs vanilla courantes : marche 0,22 bloc par tick, course
|
||||
* 0,28, saut en courant environ 0,36). Elles seront resserrées avec les traces réelles (enregistreur).
|
||||
*/
|
||||
public final class VitesseHorizontale {
|
||||
|
||||
public static final double MARCHE = 0.23;
|
||||
public static final double COURSE = 0.30;
|
||||
public static final double COURSE_SAUT = 0.42;
|
||||
public static final double FURTIF = 0.07;
|
||||
public static final double RALENTI_OBJET = 0.12;
|
||||
/** Les ticks d'historique conservés pour le tampon d'excès. */
|
||||
public static final int FENETRE_TICKS = 20;
|
||||
|
||||
private final double[] exces = new double[FENETRE_TICKS];
|
||||
private int index;
|
||||
|
||||
/** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */
|
||||
public static double vitesseMax(EtatMouvement e) {
|
||||
double v;
|
||||
if (e.furtif()) v = FURTIF;
|
||||
else if (e.ralentiParObjet()) v = RALENTI_OBJET;
|
||||
else if (e.sprint()) v = e.auSolServeur() ? COURSE : COURSE_SAUT;
|
||||
else v = e.auSolServeur() ? MARCHE : COURSE; // en l'air sans courir : l'élan d'un saut en marchant
|
||||
v *= 1.0 + 0.2 * Math.max(0, e.amplificateurVitesse());
|
||||
v *= Math.max(0.05, 1.0 - 0.15 * Math.max(0, e.amplificateurLenteur()));
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param facteur tolérance (lag)
|
||||
* @param seuilBlocs total d'excès sur la fenêtre au-delà duquel on lève une infraction
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double enregistrer(EtatMouvement e, double facteur, double seuilBlocs) {
|
||||
if (e.milieuSpecial() || e.frictionAnormale()) {
|
||||
exces[index] = 0;
|
||||
index = (index + 1) % FENETRE_TICKS;
|
||||
return 0;
|
||||
}
|
||||
int ticks = Math.max(1, e.ticks());
|
||||
double permis = vitesseMax(e) * facteur * ticks;
|
||||
double depasse = Math.max(0, e.dxz() - permis);
|
||||
exces[index] = depasse;
|
||||
index = (index + 1) % FENETRE_TICKS;
|
||||
|
||||
double total = 0;
|
||||
for (double v : exces) total += v;
|
||||
if (total <= seuilBlocs) return 0;
|
||||
return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0);
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
java.util.Arrays.fill(exces, 0);
|
||||
index = 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* Contrôle 8 : vol hors élytres. En l'air, sans exemption, la vitesse verticale doit suivre la gravité :
|
||||
* {@code vy suivante = (vy - 0,08) × 0,98}. Une montée ou un plané anormal pendant plus de 10 ticks est une
|
||||
* infraction (le plan : des VL, puis un setback).
|
||||
*/
|
||||
public final class VolVertical {
|
||||
|
||||
public static final double GRAVITE = 0.08;
|
||||
public static final double TRAINEE = 0.98;
|
||||
/** Écart toléré entre la vitesse observée et la vitesse prédite (blocs par tick). */
|
||||
public static final double TOLERANCE = 0.05;
|
||||
/** Nombre de ticks anormaux consécutifs avant la première infraction. */
|
||||
public static final int TICKS_ANORMAUX = 10;
|
||||
|
||||
private double derniereVitesse;
|
||||
private boolean aVitesse;
|
||||
private boolean etaitEnAir;
|
||||
private int anormauxConsecutifs;
|
||||
|
||||
/**
|
||||
* @param exempt joueur exempté du mouvement
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double enregistrer(EtatMouvement e, boolean exempt) {
|
||||
// Paquets groupés ou manquants : la prédiction d'un tick ne vaut plus, on oublie la vitesse précédente.
|
||||
if (e.ticks() != 1) {
|
||||
aVitesse = false;
|
||||
return 0;
|
||||
}
|
||||
boolean enAir = !e.auSolServeur();
|
||||
double dy = e.dy();
|
||||
double points = 0;
|
||||
|
||||
if (exempt || e.milieuSpecial() || !enAir) {
|
||||
anormauxConsecutifs = 0;
|
||||
} else if (etaitEnAir && aVitesse) {
|
||||
double prevue = (derniereVitesse - GRAVITE) * TRAINEE;
|
||||
boolean ecart = Math.abs(dy - prevue) > TOLERANCE;
|
||||
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08.
|
||||
if (ecart) anormauxConsecutifs++;
|
||||
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
|
||||
if (anormauxConsecutifs > TICKS_ANORMAUX) {
|
||||
points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0);
|
||||
}
|
||||
}
|
||||
|
||||
derniereVitesse = dy;
|
||||
aVitesse = true;
|
||||
etaitEnAir = enAir;
|
||||
return points;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
derniereVitesse = 0;
|
||||
aVitesse = false;
|
||||
etaitEnAir = false;
|
||||
anormauxConsecutifs = 0;
|
||||
}
|
||||
}
|
||||
@@ -7,6 +7,7 @@ import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.ModifyArg;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
||||
|
||||
/**
|
||||
@@ -30,6 +31,18 @@ public abstract class MovePacketMixin {
|
||||
if (player != null) Garde.apresMouvement(player);
|
||||
}
|
||||
|
||||
/**
|
||||
* No-fall : le drapeau « au sol » transmis aux dégâts de chute. Inchangé (comportement vanilla) tant que le
|
||||
* contrôle no-fall n'est pas en ENFORCE ; sinon le serveur exige un bloc sous le joueur.
|
||||
*/
|
||||
@ModifyArg(method = "handleMovePlayer",
|
||||
at = @At(value = "INVOKE",
|
||||
target = "Lnet/minecraft/server/level/ServerPlayer;doCheckFallDamage(DDDZ)V"),
|
||||
index = 3)
|
||||
private boolean gastinelgarde$auSolPourChute(boolean auSolClient) {
|
||||
return player != null ? Garde.auSolPourChute(player, auSolClient) : auSolClient;
|
||||
}
|
||||
|
||||
// Toute téléportation (commande, mod, perle, setback) passe par cette méthode : on marque le joueur.
|
||||
@Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD"))
|
||||
private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch,
|
||||
|
||||
@@ -4,10 +4,10 @@ license="MIT"
|
||||
|
||||
[[mods]]
|
||||
modId="gastinelgarde"
|
||||
version="0.1.0"
|
||||
version="0.2.0"
|
||||
displayName="GastinelGarde"
|
||||
authors="Théo Gastinel"
|
||||
description='''Anti-triche maison : contrôles de combat et de cadence (phase 1), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
|
||||
description='''Anti-triche maison : combat, cadence, timer (phase 1), no-fall, vitesse et vol (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
|
||||
# Les clients n'ont pas besoin du mod : ne pas exiger sa présence côté client.
|
||||
displayTest="IGNORE_ALL_VERSION"
|
||||
|
||||
|
||||
@@ -0,0 +1,261 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class MouvementTest {
|
||||
|
||||
private static EtatMouvement marche(double dxz, double dy, boolean solServeur) {
|
||||
return new EtatMouvement(dxz, dy, 1, solServeur, solServeur, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private static EtatMouvement course(double dxz, double dy, boolean solServeur) {
|
||||
return new EtatMouvement(dxz, dy, 1, solServeur, solServeur, true, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
// --- Vitesse maximale ---
|
||||
|
||||
@Test
|
||||
void vitessesDeReference() {
|
||||
assertEquals(VitesseHorizontale.MARCHE, VitesseHorizontale.vitesseMax(marche(0, 0, true)), 1e-9);
|
||||
assertEquals(VitesseHorizontale.COURSE, VitesseHorizontale.vitesseMax(course(0, 0, true)), 1e-9);
|
||||
assertEquals(VitesseHorizontale.COURSE_SAUT, VitesseHorizontale.vitesseMax(course(0, 0, false)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void effetVitesseEtLenteur() {
|
||||
EtatMouvement v2 = new EtatMouvement(0, 0, 1, true, true, true, false, false, 2, 0, false, false);
|
||||
assertEquals(VitesseHorizontale.COURSE * 1.4, VitesseHorizontale.vitesseMax(v2), 1e-9);
|
||||
EtatMouvement l1 = new EtatMouvement(0, 0, 1, true, true, true, false, false, 0, 1, false, false);
|
||||
assertEquals(VitesseHorizontale.COURSE * 0.85, VitesseHorizontale.vitesseMax(l1), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void accroupiEtRalentiParObjet() {
|
||||
EtatMouvement f = new EtatMouvement(0, 0, 1, true, true, false, true, false, 0, 0, false, false);
|
||||
assertEquals(VitesseHorizontale.FURTIF, VitesseHorizontale.vitesseMax(f), 1e-9);
|
||||
EtatMouvement o = new EtatMouvement(0, 0, 1, true, true, false, false, true, 0, 0, false, false);
|
||||
assertEquals(VitesseHorizontale.RALENTI_OBJET, VitesseHorizontale.vitesseMax(o), 1e-9);
|
||||
}
|
||||
|
||||
// --- Vitesse horizontale (tampon d'excès) ---
|
||||
|
||||
@Test
|
||||
void courseNormaleSansInfraction() {
|
||||
VitesseHorizontale v = new VitesseHorizontale();
|
||||
for (int i = 0; i < 100; i++) assertEquals(0, v.enregistrer(course(0.28, 0, true), 1.0, 1.5), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void sautEnCourantSansInfraction() {
|
||||
VitesseHorizontale v = new VitesseHorizontale();
|
||||
for (int i = 0; i < 100; i++) assertEquals(0, v.enregistrer(course(0.36, 0, false), 1.0, 1.5), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void speedHackDoubleLaVitesse() {
|
||||
VitesseHorizontale v = new VitesseHorizontale();
|
||||
double dernier = 0;
|
||||
for (int i = 0; i < 20; i++) dernier = v.enregistrer(course(0.6, 0, true), 1.0, 1.5);
|
||||
assertTrue(dernier > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void unPicIsoleEstAbsorbe() {
|
||||
VitesseHorizontale v = new VitesseHorizontale();
|
||||
assertEquals(0, v.enregistrer(course(1.0, 0, true), 1.0, 1.5), 1e-9); // 0,7 d'excès < 1,5
|
||||
}
|
||||
|
||||
@Test
|
||||
void paquetsGroupesToleres() {
|
||||
VitesseHorizontale v = new VitesseHorizontale();
|
||||
// 5 ticks de déplacement d'un coup : 5 × 0,28 = 1,4 permis
|
||||
EtatMouvement e = new EtatMouvement(1.4, 0, 5, true, true, true, false, false, 0, 0, false, false);
|
||||
assertEquals(0, v.enregistrer(e, 1.0, 1.5), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void milieuSpecialEtFrictionIgnores() {
|
||||
VitesseHorizontale v = new VitesseHorizontale();
|
||||
EtatMouvement eau = new EtatMouvement(2.0, 0, 1, false, false, false, false, false, 0, 0, true, false);
|
||||
EtatMouvement glace = new EtatMouvement(2.0, 0, 1, true, true, true, false, false, 0, 0, false, true);
|
||||
for (int i = 0; i < 30; i++) {
|
||||
assertEquals(0, v.enregistrer(eau, 1.0, 1.5), 1e-9);
|
||||
assertEquals(0, v.enregistrer(glace, 1.0, 1.5), 1e-9);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void leLagRelevaLaTolerance() {
|
||||
VitesseHorizontale v = new VitesseHorizontale();
|
||||
double max = 0;
|
||||
for (int i = 0; i < 40; i++) max = Math.max(max, v.enregistrer(course(0.40, 0, true), 1.5, 1.5)); // 0,40 < 0,45
|
||||
assertEquals(0, max, 1e-9);
|
||||
}
|
||||
|
||||
// --- No-fall ---
|
||||
|
||||
@Test
|
||||
void noFallPointsSeulementEnChuteSansSol() {
|
||||
assertEquals(0.5, NoFall.points(new EtatMouvement(0, -0.5, 1, true, false, false, false, false, 0, 0, false, false)), 1e-9);
|
||||
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.1, 1, true, false, false, false, false, 0, 0, false, false)), 1e-9);
|
||||
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.5, 1, true, true, false, false, false, 0, 0, false, false)), 1e-9);
|
||||
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.5, 1, false, false, false, false, false, 0, 0, false, false)), 1e-9);
|
||||
assertEquals(0, NoFall.points(new EtatMouvement(0, -0.5, 1, true, false, false, false, false, 0, 0, true, false)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void noFallNeCorrigeQuEnEnforce() {
|
||||
assertTrue(NoFall.auSolEffectif(true, false, false, Mode.OBSERVE));
|
||||
assertTrue(NoFall.auSolEffectif(true, false, false, Mode.OFF));
|
||||
assertFalse(NoFall.auSolEffectif(true, false, false, Mode.ENFORCE));
|
||||
assertTrue(NoFall.auSolEffectif(true, true, false, Mode.ENFORCE));
|
||||
assertTrue(NoFall.auSolEffectif(true, false, true, Mode.ENFORCE)); // exempté : on ne touche à rien
|
||||
assertFalse(NoFall.auSolEffectif(false, true, false, Mode.ENFORCE)); // jamais d'invention d'un « au sol »
|
||||
}
|
||||
|
||||
// --- Vol vertical ---
|
||||
|
||||
/** Simule une chute vanilla depuis le tick de saut. */
|
||||
private static double[] sauts(int n) {
|
||||
double[] dy = new double[n];
|
||||
double v = 0.42;
|
||||
for (int i = 0; i < n; i++) {
|
||||
dy[i] = v;
|
||||
v = (v - 0.08) * 0.98;
|
||||
}
|
||||
return dy;
|
||||
}
|
||||
|
||||
@Test
|
||||
void sautVanillaSansInfraction() {
|
||||
VolVertical vol = new VolVertical();
|
||||
assertEquals(0, vol.enregistrer(marche(0, 0, true), false), 1e-9); // au sol
|
||||
double max = 0;
|
||||
for (double dy : sauts(40)) max = Math.max(max, vol.enregistrer(marche(0.2, dy, false), false));
|
||||
assertEquals(0, max, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void chuteLibreSansInfraction() {
|
||||
VolVertical vol = new VolVertical();
|
||||
double v = 0;
|
||||
double max = 0;
|
||||
for (int i = 0; i < 60; i++) {
|
||||
v = (v - 0.08) * 0.98;
|
||||
max = Math.max(max, vol.enregistrer(marche(0, v, false), false));
|
||||
}
|
||||
assertEquals(0, max, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void flottementEnLAirEstUneInfraction() {
|
||||
VolVertical vol = new VolVertical();
|
||||
double max = 0;
|
||||
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, 0.0, false), false));
|
||||
assertTrue(max > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void monteeConstanteEstUneInfraction() {
|
||||
VolVertical vol = new VolVertical();
|
||||
double max = 0;
|
||||
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, 0.5, false), false));
|
||||
assertTrue(max > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void planeLentEstUneInfraction() {
|
||||
VolVertical vol = new VolVertical();
|
||||
double max = 0;
|
||||
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, -0.05, false), false));
|
||||
assertTrue(max > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptionCoupeLeControle() {
|
||||
VolVertical vol = new VolVertical();
|
||||
double max = 0;
|
||||
for (int i = 0; i < 40; i++) max = Math.max(max, vol.enregistrer(marche(0.2, 0.0, false), true));
|
||||
assertEquals(0, max, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void paquetsManquantsNeFontPasDInfraction() {
|
||||
VolVertical vol = new VolVertical();
|
||||
double max = 0;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
EtatMouvement e = new EtatMouvement(0.2, 0.0, 3, false, false, false, false, false, 0, 0, false, false);
|
||||
max = Math.max(max, vol.enregistrer(e, false));
|
||||
}
|
||||
assertEquals(0, max, 1e-9);
|
||||
}
|
||||
|
||||
// --- Moteur ---
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final Moteur moteur = new Moteur(cfg);
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
@Test
|
||||
void moteurRemonteLeVolEtAttendLeSeuil() {
|
||||
boolean infraction = false;
|
||||
for (int i = 0; i < 60; i++) {
|
||||
List<Verdict> v = moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), marche(0.2, 0.0, false));
|
||||
for (Verdict x : v) if (x.controle() == Controle.VOL) infraction = true;
|
||||
}
|
||||
assertTrue(infraction);
|
||||
}
|
||||
|
||||
@Test
|
||||
void moteurExempteApresRiptideEtTeleportation() {
|
||||
EtatJoueur riptide = EtatJoueur.builder().riptide(true).build();
|
||||
EtatJoueur tp = EtatJoueur.builder().ticksDepuisTeleport(3).build();
|
||||
for (int i = 0; i < 60; i++) {
|
||||
assertTrue(moteur.mouvement(joueur, i * 50L, riptide, marche(3.0, 0.5, false)).isEmpty());
|
||||
assertTrue(moteur.mouvement(joueur, i * 50L, tp, marche(3.0, 0.5, false)).isEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void moteurLesModesOffCoupentTout() {
|
||||
cfg.mode(Controle.NO_FALL, Mode.OFF);
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.VOL, Mode.OFF);
|
||||
for (int i = 0; i < 60; i++) {
|
||||
assertTrue(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), course(5.0, 1.0, false)).isEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void moteurVitesseEnObserveNeDepasseJamaisLAlerte() {
|
||||
Sanction pire = Sanction.AUCUNE;
|
||||
for (int i = 0; i < 200; i++) {
|
||||
Sanction s = Verdict.pire(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), course(1.0, 0, true)));
|
||||
if (s.ordinal() > pire.ordinal()) pire = s;
|
||||
}
|
||||
assertEquals(Sanction.ALERTE, pire);
|
||||
}
|
||||
|
||||
@Test
|
||||
void chuteLenteDuJoueurEtatEstExempteDuVol() {
|
||||
EtatJoueur chute = EtatJoueur.builder().chuteLente(true).build();
|
||||
for (int i = 0; i < 60; i++) {
|
||||
assertTrue(moteur.mouvement(joueur, i * 50L, chute, marche(0.0, -0.01, false)).isEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void auSolPourDegatsDeChuteSuitLeMode() {
|
||||
EtatJoueur e = EtatJoueur.normal();
|
||||
assertTrue(moteur.auSolPourDegatsDeChute(e, true, false)); // OBSERVE : vanilla
|
||||
cfg.mode(Controle.NO_FALL, Mode.ENFORCE);
|
||||
assertFalse(moteur.auSolPourDegatsDeChute(e, true, false));
|
||||
assertTrue(moteur.auSolPourDegatsDeChute(EtatJoueur.builder().elytres(true).build(), true, false));
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur