Fichiers
gastinel-garde/src/main/java/com/gastinelgarde/GardeEvents.java
T
gastineltetClaude Sonnet 5.5 f52587ae62 P3.3 (revue) nuker annule tout l'excedent du tick ; P3.1 auto-cristal
Revue de securite du nuker :
- Une fois le tick signale, les casses suivantes du meme tick renvoyaient 0
  sans verdict, donc n'etaient pas annulables en ENFORCE.
- La comptabilite reste separee (un tick suspect compte une fois dans la
  serie). Moteur.nukerAnnulerCasse decide l'annulation de chaque casse : vrai
  pour toute casse au-dela du plafond du tick si ce tick a donne une sanction
  >= SETBACK applicable, ou si le controle est en ENFORCE et le VL nuker deja
  au palier SETBACK. Jamais en OBSERVE.
- Tests : rafale de 30 casses par tick en ENFORCE (une infraction comptee,
  27 casses annulees) ; OBSERVE n'annule rien.

Nouveau controle auto-cristal (OBSERVE par defaut) :
- Age du cristal de l'End (ticks serveur depuis EntityJoinLevelEvent, jamais
  un cristal recharge depuis le disque) au moment du coup. Age <
  cristalDelaiMinTicks (2) = suspect ; points en serie seulement
  (cristalSerieMin 6 sur les 10 derniers coups, 60 s). Age inconnu ou > 40
  ticks : non mesure.
- Exemptions COMBAT, TPS bas, gel serveur. Chaque coup est evalue (pas de
  "signale une fois") ; en ENFORCE au palier SETBACK le coup est annule par
  le chemin existant d'onAttaque.
- Risque de faux positif eleve (PvP cristal rapide) : longue observation.
- Tests : AutoCristalP3Test (5).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 03:09:51 +02:00

265 lignes
14 KiB
Java
Brut Annotations Historique

Ce fichier contient des caractères Unicode ambigus.
Ce fichier contient des caractères Unicode qui peuvent être confondus avec d'autres caractères. Si vous pensez que c'est intentionnel, vous pouvez ignorer cet avertissement. Utilisez le bouton Échappe pour les dévoiler.
package com.gastinelgarde;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.KillauraAngle;
import com.gastinelgarde.core.PorteeHitbox;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.TraceLigne;
import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.Vec3;
import net.neoforged.bus.api.EventPriority;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.neoforge.common.util.FakePlayer;
import net.neoforged.neoforge.event.entity.living.LivingKnockBackEvent;
import net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent;
import net.neoforged.neoforge.event.entity.player.AttackEntityEvent;
import net.neoforged.neoforge.event.entity.player.PlayerEvent;
import net.neoforged.neoforge.event.level.ExplosionKnockbackEvent;
import net.neoforged.neoforge.event.server.ServerStartingEvent;
import net.neoforged.neoforge.event.server.ServerStoppedEvent;
import net.neoforged.neoforge.event.tick.ServerTickEvent;
/** Collecte des faits côté serveur (D3) : coups, déconnexions, téléportations, reculs réels, durée des ticks. */
public final class GardeEvents {
private static long debutTickNs;
private GardeEvents() { }
@SubscribeEvent
public static void onServerStarting(ServerStartingEvent event) {
Garde.demarrer();
}
@SubscribeEvent
public static void onServerStopped(ServerStoppedEvent event) {
Garde.arreter();
}
@SubscribeEvent
public static void onTickPre(ServerTickEvent.Pre event) {
debutTickNs = System.nanoTime();
Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles
}
@SubscribeEvent
public static void onTickPost(ServerTickEvent.Post event) {
long duree = System.nanoTime() - debutTickNs;
Garde.noterTickServeur(event.getServer(), duree);
if (event.getServer().getTickCount() % 20 == 0) Garde.flushTraces();
}
@SubscribeEvent
public static void onAttaque(AttackEntityEvent event) {
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
case ANNULER -> { // C4 : expulsion en cours
event.setCanceled(true);
return;
}
case IGNORER -> {
return;
}
case EVALUER -> { }
}
Entity cible = event.getTarget();
int tick = p.server.getTickCount();
EtatJoueur etat = Garde.etat(p, true);
AABB bb = cible.getBoundingBox();
Vec3 oeil = p.getEyePosition();
Vec3 regard = p.getLookAngle();
double excedent = KillauraAngle.excedentDegres(oeil.x, oeil.y, oeil.z, regard.x, regard.y, regard.z,
bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ);
boolean visible = p.hasLineOfSight(cible);
List<Verdict> verdicts = new ArrayList<>(
Garde.moteur().attaque(p.getUUID(), tick * 50L, etat, -1, cible.getId(), visible)); // angle : différé
// Portée et hitbox (test de Rednixxu, 14/10). Cible sur une contraption ou un vaisseau Sable : ses
// coordonnées et sa boîte ne sont pas fiables pour cette géométrie, on ne mesure pas.
// 16/10 : cible assise sur une contraption (siège Create) ; mesure terminée au paquet de mouvement suivant
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
Entity racine = cible.getRootVehicle();
boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
() -> SableAcces.surSousNiveau(cible), racine == cible, () -> Garde.estContraption(racine),
() -> SableAcces.surSousNiveau(racine));
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
+ Math.pow(cible.getZ() - cible.zo, 2));
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
// « vitesse × ticks » dans toutes les directions. Null (pas de mesure) si l'historique est incomplet ou si
// la cible est sur ou près d'une contraption / d'un vaisseau.
double[][] vues = mesurerPH && !Garde.cibleProcheContraption(cible, tick) ? Garde.boitesVues(cible, p, tick) : null;
verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
vitesseCible, mesurerPH, true, Garde.oeilAvant(p), vues));
if (Garde.tracesEnCours()) {
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
0, 0, 0, p.onGround(), p.onGround(), TraceLigne.masque(etat), cible.getId(), excedent,
visible ? null : "non-visible"));
}
// 0.5 (P3.1) : cristal de l'End frappé (auto-cristal), âge vu à son apparition.
if (cible instanceof net.minecraft.world.entity.boss.enderdragon.EndCrystal) {
verdicts.addAll(Garde.moteur().frappeCristal(p.getUUID(), tick * 50L, etat, Garde.ageCristal(cible, tick)));
}
Sanction s = Garde.traiter(p, verdicts);
// portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
/** 0.5 (P1.10) : coup critique vanilla (Criticals) ; en ENFORCE au palier SETBACK, le critique est annulé. */
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onCritique(net.neoforged.neoforge.event.entity.player.CriticalHitEvent event) {
if (!event.isVanillaCritical()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.noterCritique(p)) {
event.setCriticalHit(false);
event.setDamageMultiplier(1.0F);
}
}
/** 0.5 (P1.13) : diagnostic « Mismatch in destroy block pos » (vu après les autres mods, même annulé). */
@SubscribeEvent(priority = EventPriority.LOWEST, receiveCanceled = true)
public static void onClicGaucheBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock event) {
if (event.getLevel().isClientSide()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
var a = event.getAction();
// 0.5 (P2.3) : début de la mesure fast-break (START accepté par les autres mods).
if (a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START && !event.isCanceled()) {
Garde.noterDebutCasse(p, event.getPos(), event.getFace());
}
Garde.noterActionBloc(p, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START,
a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.ABORT,
event.getPos(), event.isCanceled());
}
/**
* 0.5 (P2.3) : bloc cassé par un joueur (fast-break). En ENFORCE au palier SETBACK, la casse est annulée (le bloc
* reste) ; l'expulsion s'applique comme ailleurs. Câblage non testé en jeu.
*/
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onCasse(net.neoforged.neoforge.event.level.BlockEvent.BreakEvent event) {
if (event.getLevel().isClientSide()) return;
if (!(event.getPlayer() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.noterCasse(p, event.getPos(), event.getState())) event.setCanceled(true);
}
/**
* 0.5 (P2.5) : clic droit sur un bloc, les deux mains (un client forgé peut n'envoyer que la main secondaire). Le
* client vanilla envoie main principale puis secondaire au même tick sur le même bloc : compté une fois par le
* moteur, la main secondaire reprenant la décision (annulation) de la principale.
*/
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onClicDroitBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.RightClickBlock event) {
if (event.getLevel().isClientSide()) return;
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation(),
event.getHand() == net.minecraft.world.InteractionHand.MAIN_HAND)) {
event.setCanceled(true);
}
}
/** 0.5 (P2.4) : bloc posé par un joueur (fast-place). En ENFORCE au palier SETBACK, la pose est annulée. */
@SubscribeEvent(priority = EventPriority.LOWEST)
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);
}
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
@SubscribeEvent
public static void onRelache(LivingEntityUseItemEvent.Stop event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterRelache(p, event.getItem(), event.getDuration());
}
}
/**
* F06 : la grâce de recul ne s'ouvre que si une vitesse est réellement donnée au joueur. Un dégât sans recul
* (feu, cactus, poison, wither, faim, chute : tag vanilla no_knockback) ne déclenche pas knockback().
*/
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onRecul(LivingKnockBackEvent event) {
if (event.isCanceled() || event.getStrength() <= 0.0F) return;
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterRecul(p, false);
// Vanilla retire (ratioX, ratioZ) x force à la vitesse du joueur : il part à l'opposé.
Garde.noterVelocite(p, -event.getRatioX(), -event.getRatioZ(), event.getStrength());
}
}
/** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. Celle qu'il s'inflige est limitée (GraceRecul). */
@SubscribeEvent(priority = EventPriority.LOWEST)
public static void onPousseeExplosion(ExplosionKnockbackEvent event) {
if (event.getKnockbackVelocity().lengthSqr() <= 1.0E-6) return;
if (!(event.getAffectedEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
boolean auto = event.getExplosion().getIndirectSourceEntity() == p || event.getExplosion().getDirectSourceEntity() == p;
Garde.noterRecul(p, auto);
Vec3 v = event.getKnockbackVelocity();
Garde.noterVelocite(p, v.x, v.z, Math.hypot(v.x, v.z));
}
/** Fusée de feu d'artifice tirée par un joueur : propulsion en plané, donc plané non contrôlé un moment. */
@SubscribeEvent
public static void onFusee(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
if (!(event.getEntity() instanceof net.minecraft.world.entity.projectile.FireworkRocketEntity f)) return;
// Champ privé attachedToEntity lu via l'Access Transformer (META-INF/accesstransformer.cfg) : seule une fusée
// attachée au joueur le propulse (FireworkRocketEntity.tick), jamais une fusée d'arbalète ou posée au sol.
if (f.attachedToEntity instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
int ticks = Cablage.graceFusee(true, p.isFallFlying(), event.loadedFromDisk(), f.life, f.lifetime);
if (ticks > 0) Garde.noterFusee(p, ticks);
}
}
/** 0.5 (P3.1) : apparition d'un cristal de l'End (pas un rechargement depuis le disque) : début de son âge. */
@SubscribeEvent
public static void onCristal(net.neoforged.neoforge.event.entity.EntityJoinLevelEvent event) {
if (event.getLevel().isClientSide() || event.loadedFromDisk()) return;
if (event.getEntity() instanceof net.minecraft.world.entity.boss.enderdragon.EndCrystal c && c.getServer() != null) {
Garde.noterCristal(c, c.getServer().getTickCount());
}
}
/** Totem éclaté : début de la mesure du délai de remise (auto-totem). */
@SubscribeEvent
public static void onTotem(net.neoforged.neoforge.event.entity.living.LivingUseTotemEvent event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) {
Garde.noterTotem(p, event.getHandHolding());
}
}
@SubscribeEvent
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
if (event.getEntity() instanceof ServerPlayer p) {
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
Garde.noterConnexion(p); // téléportation + 0.5 (P1.2) grâce de connexion
}
}
@SubscribeEvent
public static void onDeconnexion(PlayerEvent.PlayerLoggedOutEvent event) {
Garde.joueurParti(event.getEntity().getUUID());
}
@SubscribeEvent
public static void onChangementDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
}
@SubscribeEvent
public static void onReapparition(PlayerEvent.PlayerRespawnEvent event) {
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
}
}