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>
265 lignes
14 KiB
Java
265 lignes
14 KiB
Java
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);
|
||
}
|
||
}
|