Comparer les révisions

..
Auteur SHA1 Message Date

2026-10-25

gastineltetClaude Opus 5.5 c2a0d5403d 0.6.1-dev : correctifs revue M1-M4 (setback unique par tick, VL de la cause remis a zero, blocs fantomes, exemption nuker configurable)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 21:59:10 +01:00
gastineltetClaude Opus 5.5 67ddfff41a Version 0.6.0-dev
Build : 571 tests, 0 echec (525 + 46 nouveaux). Rien teste en jeu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:10:10 +02:00
gastineltetClaude Opus 5.5 fad2bf0437 P3.5 phase (OBSERVE par defaut) : tests + test des reglages 0.6
- Vanilla refuse deja le passage dans un bloc : le controle compte les
  positions refusees dont la boite declaree chevauche un bloc solide alors
  que la derniere position acceptee est libre (5 en 10 s).
- Tests : PhaseP06Test (8), Reglages06Test (cles 0.6 = champs GardeConfig,
  memes defauts).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:08:52 +02:00
gastineltetClaude Opus 5.5 544f11dfa5 P3.4 blink (OBSERVE par defaut) : tests
- Trou >= 30 ticks entre deux mouvements pendant lequel d'autres paquets
  (coups, clics, conteneurs, completion) arrivent a >= 2 ticks distincts,
  plus de 21 ticks apres le dernier mouvement (TCP garde l'ordre : un
  vrai lag retient tout). Un blink qui retient tout n'est pas vu.
- Tests : BlinkP06Test (9) : immobile qui clique, vrai lag, gel client,
  blink, exemptions (teleport, connexion, vehicule, gel, TPS, mort).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:08:51 +02:00
gastineltetClaude Opus 5.5 ad436ac213 P3.2 scaffold horizontal (OBSERVE par defaut) : tests
- Pose de pont sous les pieds (Scaffold.estPont) jugee au paquet de
  mouvement suivant : hors-regard (> 50 deg de l'arc de rotation entre
  deux paquets) ou snap (aller-retour > 70 deg autour de la pose).
  4 anomalies sur 10 poses en 30 s ; en ENFORCE, poses de pont annulees
  pendant 2 s apres une anomalie au palier SETBACK.
- Tests : ScaffoldP06Test (10) : pont en reculant, retournement isole,
  sans rotation, rotation silencieuse, exemptions, ENFORCE.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:08:24 +02:00
gastineltetClaude Opus 5.5 a88e4409e4 P2.6 inventaire (OBSERVE par defaut) + socle 0.6 des controles scaffold, blink, phase
- Nouveau controle inventaire (mixin ContainerClickMixin apres
  ensureRunningOnSameThread, PlayerContainerEvent.Open/Close) :
  vol-de-coffre (reaction apres ouverture ping retire plafonne, prises
  d'objets differents a <= 1,5 tick en moyenne, double-clic shift exclu),
  regard-conteneur (rotation avec conteneur ouvert apres grace + ping :
  contre le stealer "silencieux" et l'InventoryMove), clic-en-rotation
  (InvCleaner / AutoArmor), clics sur conteneur ferme (journal seulement).
- Seuils de VL propres par controle (Paliers), sections de configuration
  [inventaire], [scaffold], [blink], [phase].
- Ce commit contient deja le cablage (Garde, Moteur, mixins) des trois
  autres controles 0.6 (fichiers partages) ; leurs tests suivent dans
  les commits suivants.
- Tests : InventaireP06Test (18), MixinsThreadTest etendu.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 01:05:53 +02:00

2026-10-24

gastineltetClaude Sonnet 5.5 503da63813 Version 0.5.0
- mod_version=0.5.0 dans gradle.properties (source unique).
- Build hors ligne : 525 tests, 0 echec. Jar livrable (ignore par git) :
  SHA-256 35a058c6b277412f762e32cfe0809eee8200b7e0d07b6406756c7651793be6b6

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 03:14:21 +02:00
gastineltetClaude Sonnet 5.5 691d0a3d42 P3.7 (partie completion) : nouveau controle completion (OBSERVE par defaut)
- Vanilla 1.21.1 (handleCustomCommandSuggestions, sources NeoForge 21.1.234)
  analyse chaque demande de completion (jusqu'a 32 500 caracteres) sans
  limite de debit : un client force peut faire tirer le serveur.
- Nouveau mixin CompletionMixin, injecte juste apres
  ensureRunningOnSameThread (regle F01, verifiee par MixinsThreadTest).
- Seau a jetons : completionParSecondeMax 20/s, completionRafaleMax 40 ;
  0,25 point par demande en exces. En ENFORCE chaque demande en exces est
  ignoree (pas seulement la premiere) ; en OBSERVE rien ne change.
- Le reste de 3.7 (livres, NBT) : couvert par vanilla, voir le rapport.
- Tests : CompletionP3Test (5), MixinsThreadTest (+1).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 03:13:47 +02:00
gastineltetClaude Sonnet 5.5 b6aecade29 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>
2026-10-24 03:11:48 +02:00
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
gastineltetClaude Sonnet 5.5 bb1867f07d P3.3 : nouveau controle nuker (OBSERVE par defaut)
- Signal : blocs casses par le joueur dans un meme tick serveur
  (BlockEvent.BreakEvent). Client vanilla (MultiPlayerGameMode, sources
  NeoForge 21.1.234) : une casse au plus par tick client, destroyDelay 5
  apres un bloc non instantane.
- Plafond nukerBlocsParTickMax = 3 (gigue : ticks client groupes), points
  seulement en serie : nukerSerieMin = 3 ticks suspects parmi les 20 derniers
  ticks de casse (60 s). Section [p3] de la config.
- Exemptions famille MONDE (creatif, spectateur, contraption Create, vaisseau
  Sable, gel serveur) et TPS bas (pas de mesure).
- En ENFORCE au palier SETBACK la casse est annulee ; l'expulsion comme ailleurs.
- A verifier avant ENFORCE : un mod serveur d'abattage / minage de filon
  casse aussi plusieurs blocs au nom du joueur.
- Tests : NukerP3Test (7).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 03:07:18 +02:00
gastineltetClaude Sonnet 5.5 ee6f0a3cd4 P3.0 (revue) : expulsion en cours, interaction / casse / pose annulees
- Revue de 5397ea8, ba37380, 4d21404 (interaction-bloc) : la deduplication
  main principale / secondaire reprend bien les verdicts de la principale, et
  tout autre evenement est evalue. Mais si la main principale venait
  d'expulser le joueur (ENFORCE), la main secondaire du meme clic sortait par
  estExpulse() avec false : elle se lisait donc "autorisee".
- Desormais noterInteractionBloc, noterCasse et noterPose renvoient vrai
  (annuler) pour un joueur en cours d'expulsion, comme les coups (C4).
- P2.2 fast-eat / fast-bow : verifie dans LivingEntity.updateUsingItem
  (NeoForge 21.1.234) : le serveur decompte lui-meme useItemRemaining et
  termine l'usage ; la charge de l'arc vient du meme compteur. Rien a mesurer.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 03:05:43 +02:00
gastineltetClaude Sonnet 5.5 66faf956ee Version 0.5.0-p2
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 01:53:44 +02:00
gastineltetClaude Sonnet 5.5 6a19980656 P2.10 : nouveau controle xray statistique (alerte seulement)
- core.XrayStats : sur les 400 derniers blocs casses sous xrayAlerteYMax (16),
  au moins xrayRaresMin (12) minerais rares (diamant, debris antiques), plus de
  xrayAlerteDiamantsParCent (5 %) de rares, et au moins
  xrayAlerteNonExposesPart (80 %) de ces rares sans face a l'air, a un fluide
  ou a un bloc non plein au moment de la casse. Fenetre remise a zero apres
  une alerte. Valeurs [A VERIFIER avec les journaux].
- Jamais au-dela de l'ALERTE, meme en ENFORCE (Moteur.ajouter). Creatif et
  spectateur ignores.
- Reglages nouvelle section [xray].
- Tests : XrayP2Test (6). Cablage (BreakEvent, voisins) non teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 01:07:05 +02:00
gastineltetClaude Sonnet 5.5 45c1e6e0f0 P2.14 : nouveau controle omnisprint (OBSERVE par defaut)
- core.Omnisprint : omnisprintTicks (10) paquets d'un tick de suite au sol
  serveur, en sprint, >= 0,15 bloc/tick, hors milieu special et glace, a plus
  de omnisprintAngleDegres (100) du regard. Vanilla (LocalPlayer.aiStep,
  verifie dans les sources NeoForge 21.1.234) coupe le sprint sans entree vers
  l'avant : au plus ~45 degres. L'elan d'un demi-tour dure 2-3 ticks au sol.
- Exemptions de mouvement (recul, vehicule, contraption...), gel du serveur.
- Reglages [mouvement] : omnisprintAngleDegres, omnisprintTicks.
- Tests : OmnisprintP2Test (5). Cablage non teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 01:05:33 +02:00
gastineltetClaude Sonnet 5.5 c104868d53 P2.12 : Spider / WallClimb deja couvert par vol (tests)
- Pas de nouveau controle : la montee le long d'un mur hors echelle, lianes,
  echafaudage (milieux speciaux) viole la gravite et le controle vol (ENFORCE
  en production) la mesure deja.
- SpiderP2Test (2) : montee a 0,2 et 0,12 bloc/tick et montee par a-coups vues
  par vol ; echelle (milieu special) jamais comptee.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 01:04:19 +02:00
gastineltetClaude Sonnet 5.5 f41af7a34a P2.11 : nouveau controle jesus (OBSERVE par defaut)
- core.Jesus : jesusTicks (10) paquets d'un tick de suite au sol selon le
  client, pas au sol selon le serveur, fluide aux pieds ou juste dessous,
  aucune entite solide dessous (bateau, shulker, minecart, vaisseau Sable),
  |dy| < 0,01. Le client vanilla calcule onGround par collision et un fluide
  n'en a pas. Couvre la variante pieds dans le fluide (milieu special : vol et
  vitesse ne mesurent pas) ; la variante au-dessus est deja vue par vol.
- Exemptions de mouvement (dont vehicule et contraption), gel du serveur.
- FaitsMouvement : surFluide, entiteSolideSous (et deja dx/dz/yaw pour P2.14).
- Reglage [mouvement] : jesusTicks.
- Tests : JesusP2Test (5). Cablage (detection du fluide et des entites) non
  teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 01:03:43 +02:00
gastineltetClaude Sonnet 5.5 4d21404bcd P2.5 (revues 2 et 3) : doublons d'interaction-bloc, decision gardee
- Seconde revue de securite : le dedoublonnage par (instant, bloc) laissait
  passer tout second evenement du meme tick sur le meme bloc.
- Desormais la verification (InteractionBloc.anomalie) tourne sur chaque
  evenement. Seul le comptage des points est saute, et seulement pour la main
  secondaire qui suit la principale au meme instant, sur le meme bloc, meme
  face, meme impact, meme anomalie, une fois par instant (cle incluant la
  main). Elle reprend alors les verdicts memorises de la principale : meme
  decision d'annulation (event.setCanceled) ; un doublon n'est jamais lu comme
  autorise. Tout autre evenement (meme main repetee, autre face, autre impact,
  troisieme evenement) est evalue et compte normalement.
- Moteur.interactionBloc prend la main (0 principale, 1 secondaire) ; Garde et
  GardeEvents la transmettent.
- Autres controles P2 : aucun n'utilise ce mecanisme (fast-place regroupe les
  poses d'un meme tick pour mesurer la regularite, sans sauter de verification).
- Tests (InteractionBlocP2Test, 5 au lieu d'un) : main secondaire seule
  mesuree ; doublon vanilla compte une fois avec la meme decision ; meme main
  repetee evaluee ; autre face / impact forge evalues ; rafale sur le meme bloc
  detectee.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 01:02:57 +02:00
gastineltetClaude Sonnet 5.5 ba37380d8e P2.5 (revue) : interaction-bloc mesure aussi la main secondaire
- Revue de securite : l'ecouteur RightClickBlock filtrait MAIN_HAND ; un client
  force pouvait n'envoyer que la main secondaire et echapper au controle
  (le defaut etait dans interaction-bloc, pas dans fast-place).
- Les deux mains sont mesurees ; le clic vanilla (principale puis secondaire,
  meme tick, meme bloc) est dedoublonne par InteractionBloc.doublon (instant +
  BlockPos.asLong), nouvelle surcharge Moteur.interactionBloc.
- Autres ecouteurs P2 verifies, sans filtre de main : fast-place
  (EntityPlaceEvent, toutes mains), fast-break (LeftClickBlock / BreakEvent,
  pas de main), no-slow (isUsingItem, toutes mains), auto-totem(-regulier)
  (deux mains lues).
- Test : InteractionBlocP2Test.mainSecondaireCompteeEtDoublonsIgnores.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:59:31 +02:00
gastineltetClaude Sonnet 5.5 2777f75a8b P2.7 : nouveau controle auto-totem-regulier (OBSERVE par defaut)
- core.TotemRegulier : sur les autoTotemEchantillons (5) derniers delais
  eclatement -> totem en main, tous sous autoTotemRegulierMaxMs (300 ms) et
  ecart type sous autoTotemEcartTypeMinMs (30 ms) : AutoTotem a delai fixe qui
  passe au-dessus du seuil minimal d'auto-totem.
- Controle separe d'auto-totem (en ENFORCE en production, inchange) ; le suivi
  de l'eclatement reste actif si l'un des deux est actif. AutoTotem expose le
  dernier delai mesure (prendreDelai).
- Test existant ajuste : NouveauxControlesTest.v041_... ne compte plus que les
  verdicts auto-totem (le nouveau controle ajoute ses propres verdicts).
- Reglages [monde] : autoTotemEchantillons, autoTotemEcartTypeMinMs,
  autoTotemRegulierMaxMs.
- Tests : TotemRegulierP2Test (5). Cablage inchange (meme evenement totem).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:58:42 +02:00
gastineltetClaude Sonnet 5.5 5397ea8c6e P2.5 : nouveau controle interaction-bloc (OBSERVE par defaut)
- core.InteractionBloc : clic droit sur un bloc (RightClickBlock, main
  principale) ou debut de casse (LeftClickBlock START, sans impact) impossible
  pour le rayon du client vanilla : bloc d'air (AirPlace), oeil derriere le plan
  de la face cliquee (a travers un bloc, Scaffold simple), impact hors de la
  face d'un bloc plein (vecteur forge), portee de bloc + marge depassee.
- Marge interactionBlocMarge (0,5) + deplacement de l'oeil au dernier tick (le
  rayon du client part de l'oeil interpole). Au-dela de portee + 1 vanilla
  refuse (handleUseItemOn, verifie dans les sources NeoForge 21.1.234) : si
  l'evenement arrive quand meme, un mod a transforme les coordonnees (Sable),
  rien n'est mesure. Forme de contour reelle du bloc (dalles, escaliers).
- Points en serie : interactionBlocSerieMin (3) anomalies sur les 10 dernieres
  interactions en 60 s. Exemptions MONDE (creatif, spectateur, contraption,
  gel, connexion). En ENFORCE au palier SETBACK le clic droit est annule ; le
  debut de casse n'est jamais annule (expulsion seulement).
- Reglages [monde] : interactionBlocMarge, interactionBlocSerieMin.
- Tests : InteractionBlocP2Test (7). Cablage non teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:55:42 +02:00
gastineltetClaude Sonnet 5.5 fad4da8f7c P2.4 : nouveau controle fast-place (OBSERVE par defaut)
- core.FastPlace : sur les fastPlaceSerie (40) derniers intervalles entre deux
  poses (BlockEvent.EntityPlaceEvent, poses du meme tick regroupees), au moins
  fastPlaceRegularite (90 %) valent exactement le meme nombre de ticks, au plus
  fastPlaceIntervalleMaxTicks (1 : une pose a chaque tick).
- Pas de plafond de poses par seconde : le drag-click humain depasse 20 clics
  par seconde ; vanilla au clic maintenu pose toutes les 4 ticks
  (rightClickDelay), jamais a chaque tick avec cette regularite. Une pause de
  plus d'une seconde remet la serie a zero.
- Test de pire cas : poses de Poisson a 20/s pendant 60 s, jamais vues (avec
  20 intervalles au lieu de 40, des fausses alertes apparaissaient a 30/s).
- En ENFORCE au palier SETBACK la pose est annulee.
- Reglages [monde] : fastPlaceSerie, fastPlaceRegularite,
  fastPlaceIntervalleMaxTicks.
- Tests : FastPlaceP2Test (7). Cablage non teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:52:23 +02:00
gastineltetClaude Sonnet 5.5 9652b48ea6 P2.3 : nouveau controle fast-break (OBSERVE par defaut)
- core.FastBreak : a la casse (BlockEvent.BreakEvent) d'un bloc dont le START
  a ete vu au meme endroit, rapport = getDestroyProgress x (ticks + 1). Vanilla
  (ServerPlayerGameMode.handleBlockBreakAction, verifie dans les sources
  NeoForge 21.1.234) accepte des 0,7 ; suspect sous fastBreakFacteur (0,8).
- Points seulement en serie : fastBreakSerieMin (4) casses suspectes sur les
  10 dernieres mesurees en 60 s. Pas de mesure : blocs < fastBreakTicksMin (6)
  ticks, casse instantanee, START ailleurs, creatif/spectateur, contraption et
  vaisseau Sable, gel du serveur, TPS bas, connexion recente.
- Exemptions.Famille.MONDE (casse et pose de blocs) ; core.SerieFenetre (serie
  generique k sur n dans une fenetre).
- En ENFORCE au palier SETBACK la casse est annulee ; expulsion comme ailleurs.
- P2.2 FastEat/FastBow : rien a coder, l'usage d'objet est compte par le
  serveur (LivingEntity.updateUsingItem, tick du joueur par le serveur).
- Reglages [monde] : fastBreakFacteur, fastBreakTicksMin, fastBreakSerieMin.
- Tests : FastBreakP2Test (8). Cablage non teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:49:49 +02:00
gastineltetClaude Sonnet 5.5 c49cf985d8 P2.1 : nouveau controle no-slow (OBSERVE par defaut)
- core.NoSlow : vitesse au sol > noSlowFacteur (0,5) x course (0,30) x effets
  pendant un usage d'objet, noSlowTicks (10) paquets de suite. Vanilla
  (LocalPlayer.aiStep, verifie dans les sources NeoForge 21.1.234) : entree
  x0,2 en usage d'objet, sprint deja lance garde (~0,056 bloc/tick).
- Pas de mesure : noSlowGraceTicks (3) premiers ticks d'usage, moins de 3
  paquets au sol de suite, saut, glace/slime/ames, milieu special, paquets
  groupes, gel du serveur, exemptions de mouvement (creatif, spectateur,
  vehicule, contraption/Sable, recul, teleportation, connexion).
- core.FaitsMouvement + Moteur.mouvementP2 : faits supplementaires du paquet
  (ticks d'usage) sans toucher la signature de Moteur.mouvement (rejeu).
- Reglages [mouvement] : noSlowFacteur, noSlowGraceTicks, noSlowTicks.
- Tests : NoSlowP2Test (8). Cablage non teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:47:41 +02:00
gastineltetClaude Sonnet 5.5 adc326a897 P1.13 : diagnostic « Mismatch in destroy block pos »
- core.ActionsBloc : START / ABORT de casse de bloc (LeftClickBlock, ecoute
  en LOWEST, meme annule). Un ABORT sans START accepte correspondant donne
  une ligne DIAGNOSTIC (au plus une toutes les 10 s par joueur), avec le
  dernier START et s'il a ete annule par un mod.
- D'apres ServerPlayerGameMode (sources NeoForge 21.1.234), destroyPos vaut
  (0,0,0) tant qu'aucun START n'a ete accepte : un START annule par une
  protection de zone puis un ABORT suffit a produire le message.
- Reglage [diagnostic] : actionsBlocIncoherentes (true). Jamais de sanction.
- Tests : ActionsBlocP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:36:45 +02:00
gastineltetClaude Sonnet 5.5 7c86d634b9 P1.6 : elytres, deploiements repetes (ElytraFly « packet »)
- core.DeploiementsElytres : plus de elytresDeploiementsMax (5) passages en
  plane sur 1 s = infraction du controle « elytres » (OBSERVE en production).
  Mecanisme verifie dans les sources NeoForge 21.1.234 : un START_FALL_FLYING
  recu pendant le plane l'arrete (tryToStartFallFlying faux -> stopFallFlying),
  le suivant le relance : le spam fait basculer le drapeau vu par le serveur.
- Garde.apresMouvement : transition isFallFlying entre deux paquets.
- Non fait : vitesse 3D maximale en plane (valeur 3,4 non verifiee) et
  elytresExemptionStricte (C7) laisse a false (il toucherait vol, ENFORCE en
  production).
- Tests : ElytresP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:35:10 +02:00
gastineltetClaude Sonnet 5.5 fc34047e65 P1.8 : nouveau controle anti-faim (OBSERVE par defaut)
- core.AntiFaim : antiFaimTicks (20) paquets de suite ou le serveur voit le
  joueur courir au sol sur du plat (dy nul, dxz >= 0,1, un tick) alors que
  le client se declare en l'air. Vanilla (ServerPlayer.checkMovementStatistics,
  verifie dans les sources NeoForge 21.1.234) ne compte la faim de course que
  si onGround, drapeau venu du client.
- Exemptions de mouvement, milieux speciaux, plusieurs ticks : pas de mesure.
- Reglage [mouvement] : antiFaimTicks.
- Tests : AntiFaimP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:33:52 +02:00
gastineltetClaude Sonnet 5.5 23dc2bca12 P1.10 : nouveau controle criticals (OBSERVE par defaut)
- core.Criticals : hauteur suivie depuis le dernier « au sol » du client ;
  au coup critique vanilla (CriticalHitEvent.isVanillaCritical), suspect si
  ni montee ni descente au-dela de criticalsMicroSautMax (0,1). Points
  seulement en serie (criticalsSerieMin = 3 sur les 10 derniers en 60 s).
  Conditions vanilla du critique verifiees dans Player.attack (NeoForge
  21.1.234).
- ENFORCE : au palier SETBACK le critique est annule (multiplicateur 1) ;
  l'expulsion s'applique comme pour le combat. Exemptions de combat.
- Reglages [combat] : criticalsMicroSautMax, criticalsSerieMin.
- Tests : CriticalsP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:32:48 +02:00
gastineltetClaude Sonnet 5.5 50b3f211a3 P1.9 : nouveau controle step (OBSERVE par defaut)
- core.Step : au sol serveur au paquet precedent et a celui-ci, en un seul
  tick, gain > max(stepHauteurMax, attribut step_height, saut) + marge.
  Valeurs vanilla verifiees dans les sources NeoForge 21.1.234 :
  step_height 0,6 ; jump_strength 0,42 ; +0,1 par niveau de Saut ameliore.
- Pas de mesure : plusieurs ticks entre deux paquets, milieu special,
  exemption de mouvement, piston en mouvement autour du joueur (NaN),
  ancienne signature de Moteur.mouvement (traces, rejeu).
- Reglages [mouvement] : stepHauteurMax (0.6), stepMargeBlocs (0.1).
  Fiabilite « faible » (plafond 15 du score).
- Tests : StepP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:30:22 +02:00
gastineltetClaude Sonnet 5.5 d7a6772c42 P1.12 : timer, solde actif par defaut (20), dette reglable, connexion ignoree
- timerSoldeMax : 20 par defaut (avant 0). Attention : un fichier de
  configuration existant garde sa valeur (0 en production) ; rien ne change
  sur le serveur tant que le fichier n'est pas modifie a la main.
- timerDetteMax (40, avant constante CREDIT_MAX) : credit remboursable par la
  rafale de rattrapage apres un lag.
- La grace de connexion (P1.2) ignore aussi le timer.
- Tests : TimerP1Test ; ControlesTest, AutotestContournementsTest et
  CablageMinecraftTest ajustes au nouveau defaut.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:27:25 +02:00
gastineltetClaude Sonnet 5.5 3507f785a5 P1.4 : version 0.5.0-p1, une seule source (gradle.properties)
- gradle.properties : mod_version=0.5.0-p1.
- neoforge.mods.toml : version="${mod_version}", rempli par processResources.
- Manifeste du jar : Implementation-Title / -Version / -Vendor.
- Version affichee au chargement, au demarrage (journal) et dans /garde status.
- Tests : VersionP1Test (toml traite == gradle.properties, pas de version en
  dur dans la source).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:24:49 +02:00
gastineltetClaude Sonnet 5.5 d21eaa2e50 P1.3 : motif de sanction, plus fort VL en cas d'egalite, autres controles au journal
- Cablage.raison : parmi les verdicts au palier de la sanction, celui de plus
  fort VL (avant : le premier dans l'ordre de l'enum).
- Cablage.motifJournal : « vol ; aussi : vitesse » dans les lignes EXPULSE,
  SETBACK, SETBACK au sol et SETBACK impossible. Le message au joueur garde
  le seul motif retenu.
- Tests : CablageSuspicionTest (b_P13_*).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:22:59 +02:00
gastineltetClaude Sonnet 5.5 7b19f86ff9 P1.2 : grace de connexion, plus longue apres une expulsion, setback au sol
- Grace de connexion (mouvement, vehicule, timer ; pas le combat) :
  graceConnexionTicks (100), graceApresExpulsionTicks (200) si expulse il y a
  moins de 10 min (Moteur.graceConnexionTicks, memoire qui survit a la
  reconnexion). Ligne de journal a la reconnexion apres expulsion.
- Sans position de retour valide, le SETBACK ramene au sol juste sous le
  joueur (meme x, z, au plus 64 blocs, jamais vers le haut ni de cote) :
  setbackSolSiPasDePosition (true). Sinon « SETBACK impossible » (P1.1).
- Nouvelle section [graces].
- Tests : ReconnexionP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:22:09 +02:00
gastineltetClaude Sonnet 5.5 b72e5717c5 P1.1 : journal, tout SETBACK/EXPULSION toujours ecrit, setback rate journalise
- Cablage.ecrireVerdict : le verdict qui declenche un SETBACK ou une EXPULSION
  passe outre la limite d'une ligne par seconde et par controle.
- Cablage.appliquerSanction : « SETBACK impossible » ecrit (pas de position
  de retour, ou position dans une autre dimension).
- Nouvelle section [journal] : toujoursEcrireSanctions (true),
  limiteLignesParSeconde (1).
- Tests : JournalP1Test, CablageTest et CablageSuspicionTest mis a jour.

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

2026-10-23

gastineltetClaude Opus 5.5 e87b8374ef 0.4.2 : vraies sanctions pour auto-totem et velocite, seuils propres
- bride ALERTE retiree en ENFORCE ; auto-totem : palier SETBACK ramene a ALERTE, expulsion appliquee
- velocite : SETBACK = retour en arriere (setback mouvement existant), expulsion
- seuils optionnels dans [nouveauxControles] : autoTotemSeuilSetback (0 = global), autoTotemSeuilExpulsion = 9,
  velociteSeuilSetback = 8, velociteSeuilExpulsion = 16 (0 = seuil global de [sanctions])
- version 0.4.2

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 19:38:40 +02:00
gastineltetClaude Opus 5.5 26d610f79a 0.4.1 : reglages velocite, elytres, auto-totem, version
- velocite : points par recul absent configurables (velocitePoints, defaut 4 au lieu de 2 en dur)
- elytres : grace de fusee tenue si la vitesse 3D reste proche de la poussee (montee avec fusee),
  marge 20 ticks, vie bornee a 60 ; au plus 1,5 point par periode au lieu de 1,5 par paquet
- auto-totem : controle fiable (plafond 50) dans le score de suspicion ; trace d'eclatement au journal
- version 0.4.1 (gradle.properties, neoforge.mods.toml)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 19:31:56 +02:00
gastineltetClaude Sonnet 5.5 59dea0d436 Plane : etat vide des qu'on n'est plus en plane ; refus de grace avec pause
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:11:55 +02:00
gastineltetClaude Sonnet 5.5 40c89825de Plane : pas de nouvelle fenetre de grace apres un refus avant une pause
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:11:11 +02:00
gastineltetClaude Sonnet 5.5 c92ebb055a Plane : fusees enchainees cumulees, reference de vitesse hors grace et reinitialisee
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:10:28 +02:00
gastineltetClaude Sonnet 5.5 1116f6137b Fusee : mediane du gain de vitesse ; velocite : blocage directionnel, 2 ticks pour abandonner
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:08:23 +02:00
gastineltetClaude Sonnet 5.5 c5bd0265f6 Fusee : grace seulement si attachee au joueur en plane, vie reelle, compteurs suspendus ; velocite bridee (jamais de sanction), joueur coince ecarte
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:04:49 +02:00
gastineltetClaude Sonnet 5.5 22ccc5fa59 GastinelGarde 0.4.0 : version et CHANGELOG
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:00:57 +02:00
gastineltetClaude Sonnet 5.5 334cc5b45c GastinelGarde 0.4.0 : controles elytres, velocite, auto-totem (OBSERVE par defaut)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 16:00:04 +02:00
gastineltetClaude Sonnet 5.5 80c9748a23 Vol : flottement durci contre les rafales a 0 tick et les trous de ticks
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 15:56:23 +02:00
gastineltetClaude Sonnet 5.5 c7b130ec1c GastinelGarde 0.4.0 : score de suspicion, flottement du vol, motif de sanction corrige
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-23 15:52:27 +02:00

2026-10-16

gastineltetClaude Sonnet 5.5 288087080f gitignore : livrable/
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:15:06 +02:00
gastineltetClaude Sonnet 5.5 9b5273f830 GastinelGarde 0.3.1 : version, CHANGELOG, README
Passe mod_version et neoforge.mods.toml en 0.3.1, ajoute CHANGELOG.md
(resume des correctifs, options nouvelles desactivees par defaut, modes inchanges).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 10:13:26 +02:00
gastineltetClaude Opus 5.5 d90e40c8b9 GastinelGarde tests : cablage NeoForge (evenements, bytecode, options, FAILLE_C4 vehicule)
CablageMinecraftTest (9 tests, sans serveur) : evenements abonnes, gardes
d'expulsion lues dans le bytecode, types d'entites C18/F20, options C7 C8
C10 C15 C18 desactivees par defaut et recopiees par GardeSpec.appliquer
(fichier charge en memoire). FAILLE_C4_apresVehicule... : vert tant que
apresVehicule ignore la marque d'expulsion (non corrige). 291 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 6e208dccd2 GastinelGarde : couche Cablage testable (Garde, GardeEvents) et ses tests
Decisions du cablage Minecraft sorties sans changement de comportement :
entrees des evenements (C4 expulsion, F01, exemption manuelle), annulation
du coup, exemption contraption de la cible, C7 transition elytres, cache des
detections, position de retour (C3), sanction setback/expulsion (C2, C4)
via une interface Joueur (doublure dans les tests). Evaluation paresseuse
conservee. CablageTest : 16 tests. 266 -> 282 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 3dc39c8043 GastinelGarde : correctifs C7, C8, C18 derriere options desactivees par defaut
- C7 elytresExemptionStricte : plane declenche moins de elytresAirMinTicks (2)
  ticks apres le dernier sol serveur = pas d exemption de mouvement ;
  portee/hitbox mesurees pendant le plane.
- C8 combatMesureEnVehicule : passager mesure comme a pied (contraption reste exemptee).
- C18 empilementSeulementEnMouvement : minecart contenant immobile non casse, journalise.
266 tests, 0 echec (cornafserver).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:02:09 +02:00
gastineltetClaude Opus 5.5 5eeb916add GastinelGarde tests inverses CORRIGE_C7, C8, C18 (rouges) et ebauches sans effet
Options desactivees par defaut : elytresExemptionStricte, elytresAirMinTicks,
combatMesureEnVehicule, empilementSeulementEnMouvement ; champ
EtatJoueur.elytresDeploiementSuspect ; AntiCrashEntites.empilementACasser.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:32:46 +02:00
gastineltetClaude Opus 5.5 f19fe6444b GastinelGarde tests : FAILLE_C7, FAILLE_C8, FAUX_POSITIF_C18 (verts tant que le defaut existe)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:31:36 +02:00
98 fichiers modifiés avec 9548 ajouts et 95 suppressions

Aucun fichier ne correspond à votre recherche

+1
Voir le fichier
@@ -7,3 +7,4 @@ run/
# sauvegardes avant modification
*.avant-*
livrable/
+67
Voir le fichier
@@ -0,0 +1,67 @@
# Journal des versions
## 0.6.0-dev (non publiée, branche feat/garde-0.6, dérivée de feat/garde-0.5)
Testé hors jeu seulement (JUnit) ; rien n'a été essayé sur un serveur Minecraft. Quatre nouveaux contrôles, tous en
OBSERVE par défaut, chacun avec sa section et ses seuils de VL propres (`[inventaire]`, `[scaffold]`, `[blink]`, `[phase]`) :
- `inventaire` : ChestStealer (réaction après l'ouverture, prises rapides d'objets différents), rotation avec un conteneur
ouvert (stealer silencieux, InventoryMove), clic sur l'inventaire pendant que la tête tourne (InvCleaner / AutoArmor).
Nouveau mixin `ContainerClickMixin` (après ensureRunningOnSameThread).
- `scaffold` : pont posé sous les pieds hors du regard, ou avec une rotation aller-retour (snap) autour de la pose.
- `blink` : trou de paquets de mouvement pendant que d'autres paquets arrivent.
- `phase` : positions refusées par vanilla dont la boîte est dans un bloc solide, en série (vanilla bloque déjà le passage).
## 0.4.0 (non publiée, branche feat/suspicion-score, dérivée de release/0.3.1 = jar déployé)
Testé hors jeu seulement (JUnit) ; rien n'a été essayé sur un serveur Minecraft. Aucun mode existant n'est modifié.
- Score de suspicion 0-100 par joueur (section `[suspicion]`) : journal dès 25, message aux ops dès 50, dès 75 simple
proposition « suspect_2 à valider dans le Portail ». Jamais de sanction ni de bannissement à partir du score.
Historique des incidents par UUID sur 7 jours dans `gastinelgarde-suspicion/incidents.csv`. `/garde status <joueur>`
affiche le score. Pas de signalement au Hub (absent de cette base, voir le rapport).
- Vol : flottement prolongé (`volFlottementTicks` = 80, équivalent du « kicked for floating too long » vanilla), pour
pouvoir passer `allow-flight=true`. Insensible aux paquets à 0 tick et aux trous de ticks.
- Nouveaux contrôles, OBSERVE par défaut : `elytres` (Elytra Hack), `velocite` (Anti Knockback / Anti Push),
`auto-totem` (section `[nouveauxControles]`).
- Correctif : le motif écrit pour une sanction (journal, message d'expulsion) est celui du verdict qui sanctionne,
plus celui du premier verdict de la liste.
## 0.3.1 (16/10/2026)
Version de correctifs. Les modes OBSERVE / ENFORCE de chaque contrôle sont inchangés (aucun défaut de mode modifié).
Toutes les options nouvelles sont désactivées par défaut : sans changement de config, seuls les correctifs « actifs
sans option » ci-dessous changent le comportement. Tout est testé hors jeu seulement ; rien n'a été essayé en jeu.
### Vol et élytres (incident VOL du 15/10, branche fix/vol-elytres)
- C1 : grâce de fin de plané en élytres bornée (`graceFinElytresTicks` = 50 ticks, finit à l'atterrissage).
- C2 : après un setback, vol, vitesse et points VOL / VITESSE remis à zéro.
- C3 : position de retour du setback = dernière position au sol (ou milieu spécial : eau, échelle).
- C4 : expulsion à usage unique (une ligne EXPULSE), contrôles de nouveau actifs après reconnexion. Jamais de bannissement.
- C5 : escalade : expulsion seulement après 4 setbacks en 60 s.
### Coups-hors-boite, portée, C10, C13, C15 (branche fix/hitbox-c10-c13-c15)
- Le ping élevé (> 500 ms) n'exempte plus le coup ; fenêtre bornée à `seriePingMaxMs`.
- Œil / regard suivants bornés (un tick, 90°) ; éviction de la cible non joueur la plus ancienne quand la table est pleine.
- Fenêtre de ping fondée sur le plancher des 2 dernières minutes (`PingPlancher`, `seriePingMargeMs` = 50 ms).
- Options (désactivées par défaut) : `volFenetreGlissante` (C10, sauts en l'air espacés), `vitesseMoyenne` (C15, bhop / sol),
`timerSoldeMax` (C15, timer ; 0 = désactivé, essai conseillé 20).
- Seuils de `portee` / `hitbox` non resserrés.
### Rafales réseau (branche fix/rafales-reseau)
- Faux positif VOL sur chute reçue en rafales (3, 0, 0) corrigé : ticks dus bornés (`AVANCE_MAX` = 4). Actif sans option ;
la chute ralentie par triche reste détectée.
### Constats hauts (branche fix/constats-hauts)
- Options (désactivées par défaut) : `elytresExemptionStricte` (C7), `combatMesureEnVehicule` (C8),
`empilementSeulementEnMouvement` (C18, minecarts à contenu immobiles non cassés).
- C27 (modes vol / portée / hitbox en production) : décision de config, non traitée par le code.
### Tests du câblage Minecraft (branche test/cablage-minecraft)
- Refactoring sans changement de comportement : classe `Cablage` (entrées d'événements, sanctions, C7).
- `CablageTest` et `CablageMinecraftTest` ajoutés.
- Défaut connu non corrigé : `Garde.apresVehicule` ne consulte pas la marque d'expulsion (test `FAILLE_C4_...`).
### Version
- `gradle.properties` et `neoforge.mods.toml` en 0.3.1 ; jar `gastinelgarde-neoforge-1.21.1-0.3.1.jar`.
## 0.3.0
Corrections de l'audit du 14/10/2026 (voir `audit/CORRECTIONS.md`).
+2 -2
Voir le fichier
@@ -1,7 +1,7 @@
# 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.3.0** : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
`../PLAN-GASTINELGARDE.md`. Version **0.3.1** (voir `CHANGELOG.md`) : phases 0, 1 et 2 du plan, plus les corrections de l'audit du
2026-10-14 (`audit/`).
**État** : compilé, 180 tests JUnit verts (au 16/10) (cœur pur, commandes, configuration, application réelle des mixins,
@@ -251,7 +251,7 @@ journaliser et alerter (le coup a déjà eu lieu quand l'aller-retour est vu).
Les traces JSONL se rejouent dans le moteur, sans serveur :
```
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.0.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.3.1.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
```
Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode :
+23
Voir le fichier
@@ -44,6 +44,29 @@ test {
testLogging { events 'passed', 'failed'; exceptionFormat 'full' }
}
// 0.5 (P1.4) : une seule source de version (gradle.properties) : neoforge.mods.toml et le manifeste du jar.
processResources {
def props = [mod_version: project.mod_version]
inputs.properties props
filesMatching('META-INF/neoforge.mods.toml') { expand props }
}
jar {
manifest {
attributes(
'Implementation-Title': 'GastinelGarde',
'Implementation-Version': project.mod_version,
'Implementation-Vendor': 'Theo Gastinel'
)
}
}
test {
// Le test de version compare le neoforge.mods.toml traité à gradle.properties.
systemProperty 'gastinelgarde.version', project.mod_version
systemProperty 'gastinelgarde.projet', project.projectDir.absolutePath
}
tasks.withType(JavaCompile).configureEach {
options.encoding = 'UTF-8'
options.release = 21
+2
Voir le fichier
@@ -159,6 +159,8 @@
#Minecarts superposés au plus : au-delà, poussée mutuelle coupée et excédentaires (sans passager) cassés. 0 = pas de limite.
# Range: 0 ~ 64
minecartsSuperposesMax = 4
#C18 : ne casser que les minecarts empilés en mouvement ou sans contenu (défaut false, décision de Théo)
empilementSeulementEnMouvement = false
alertesOps = true
#Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.
+1 -1
Voir le fichier
@@ -1,7 +1,7 @@
org.gradle.jvmargs=-Xmx2G
org.gradle.parallel=true
mod_version=0.3.0
mod_version=0.6.1-dev
mod_group_id=com.gastinelgarde
mod_id=gastinelgarde
+258
Voir le fichier
@@ -0,0 +1,258 @@
package com.gastinelgarde;
import com.gastinelgarde.core.DetectionContraption;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Suivi;
import com.gastinelgarde.core.Verdict;
import java.util.List;
import java.util.UUID;
import java.util.function.BooleanSupplier;
/**
* Décisions du câblage Minecraft (Garde, GardeEvents) sorties sans changement de comportement (16/10, constat C4 ⚠️),
* pour être testées sans serveur. Aucun type Minecraft ici : Garde et GardeEvents lisent le serveur, appellent ces
* méthodes et appliquent le résultat.
*/
final class Cablage {
private Cablage() { }
// --- Entrées des événements ---
/** Ce que fait onAttaque avant toute mesure. */
enum EntreeAttaque {
/** C4 : expulsion en cours, le coup est annulé et rien n'est évalué. */
ANNULER,
/** Exemption manuelle (/garde exempter) : le coup passe sans mesure. */
IGNORER,
EVALUER
}
static EntreeAttaque entreeAttaque(boolean expulse, boolean exempteManuellement) {
if (expulse) return EntreeAttaque.ANNULER;
if (exempteManuellement) return EntreeAttaque.IGNORER;
return EntreeAttaque.EVALUER;
}
/** Fin de onAttaque : le coup est-il annulé ? (portée / hitbox ENFORCE, ou sanction ≥ SETBACK). */
static boolean annulerCoup(boolean coupsBloques, Sanction s) {
return coupsBloques || s.ordinal() >= Sanction.SETBACK.ordinal();
}
/** Fin de onAttaque : seule une EXPULSION est appliquée au joueur (un SETBACK de combat annule seulement le coup). */
static boolean appliquerApresCoup(Sanction s) {
return s == Sanction.EXPULSION;
}
/** avantMouvement : évaluer ce paquet ? (F01 thread serveur, C4 expulsion, exemption manuelle). */
static boolean evaluerAvantMouvement(boolean surThreadServeur, BooleanSupplier expulse,
BooleanSupplier exempteManuellement) {
// Paresseux : hors du thread serveur, l'état du mod n'est pas lu du tout (F01).
return surThreadServeur && !expulse.getAsBoolean() && !exempteManuellement.getAsBoolean();
}
/** apresMouvement : traiter ce paquet (état, position, traces) ? L'exemption manuelle est vue plus loin. */
static boolean traiterApresMouvement(boolean surThreadServeur, BooleanSupplier expulse) {
return surThreadServeur && !expulse.getAsBoolean();
}
/** Sanction de mouvement à appliquer (≥ SETBACK). */
static boolean sanctionDeMouvement(Sanction s) {
return s.ordinal() >= Sanction.SETBACK.ordinal();
}
// --- Exemptions contraption de la cible (portée / hitbox) ---
/**
* Portée et hitbox mesurées ? Non si la cible, ou son véhicule racine, est une contraption ou sur un vaisseau
* Sable. Évaluation paresseuse dans le même ordre que l'ancien code.
*/
static boolean mesurerPorteeHitbox(BooleanSupplier cibleContraption, BooleanSupplier cibleSable,
boolean racineEstCible, BooleanSupplier racineContraption,
BooleanSupplier racineSable) {
return !cibleContraption.getAsBoolean() && !cibleSable.getAsBoolean()
&& (racineEstCible || (!racineContraption.getAsBoolean() && !racineSable.getAsBoolean()));
}
// --- C7 : déploiement des élytres ---
/** Suivi du plané en cours : est-il commencé moins de elytresAirMinTicks après le dernier sol serveur ? */
static final class Elytres {
boolean vues;
boolean suspectes;
/** À chaque construction de l'état : transition isFallFlying. */
void observer(boolean plane, int solServeurTick, int tick, int airMinTicks) {
if (plane) {
if (!vues) {
vues = true;
suspectes = solServeurTick != Integer.MIN_VALUE && tick - solServeurTick < airMinTicks;
}
} else {
vues = false;
suspectes = false;
}
}
}
// --- Détection en cache (contraption, courant d'air) ---
/** Détection refaite au plus toutes les 10 ticks, puis grâce après la dernière détection positive. */
static final class CacheDetection {
int tick = Integer.MIN_VALUE;
int vuTick = Integer.MIN_VALUE;
boolean proche;
boolean lire(int maintenant, BooleanSupplier detecter, int graceTicks) {
if (tick == Integer.MIN_VALUE || maintenant - tick >= 10 || maintenant < tick) {
proche = detecter.getAsBoolean();
tick = maintenant;
if (proche) vuTick = maintenant;
}
return proche || DetectionContraption.dansLaGrace(maintenant, vuTick, graceTicks);
}
}
// --- 0.4.0 : grace de propulsion d'une fusee (plane en elytres) ---
/** Ticks de marge après la fin de vie de la fusée (dernier tick de poussée, retard d'état). */
static final int MARGE_FUSEE_TICKS = 20;
/** 0.4.1 : duree de vie vanilla d'une fusee : 10 x (1 + duree de vol) + 0..11, soit 20 a 51 ticks pour les durees 1 a 3. */
static final int VIE_FUSEE_MAX = 60;
/**
* Grâce de propulsion accordée à l'apparition d'une fusée : seulement si elle est réellement attachée au joueur
* (propulsion en plané, pas une fusée d'arbalète ou posée au sol), si le joueur plane à cet instant, et si elle
* ne vient pas d'être rechargée depuis le disque. Durée : vie restante réelle de la fusée + marge, au lieu de 6 s
* fixes (un tricheur qui tire une fusée toutes les quelques secondes n'obtient jamais plus que la vie de la fusée).
*
* @return nombre de ticks de grâce (0 = aucune)
*/
static int graceFusee(boolean attacheeAuJoueur, boolean joueurPlane, boolean rechargeeDuDisque, int vie, int dureeDeVie) {
if (!attacheeAuJoueur || !joueurPlane || rechargeeDuDisque) return 0;
int restant = Math.max(0, dureeDeVie - Math.max(0, vie));
return Math.min(restant, VIE_FUSEE_MAX) + MARGE_FUSEE_TICKS;
}
// --- Position de retour (C3) ---
/** apresMouvement : la position de ce paquet devient-elle la position de retour ? */
static boolean memoriserRetour(Moteur moteur, int dernierVerdictTick, int tick, BooleanSupplier vehiculeControle,
boolean solServeur, boolean milieuSpecial) {
return dernierVerdictTick != tick && !vehiculeControle.getAsBoolean()
&& moteur.positionDeRetourAdmise(solServeur, milieuSpecial);
}
// --- 0.5 (P1.1) : journal des verdicts ---
/**
* Ligne de journal pour ce verdict ? Le journal est limité (une ligne par seconde et par contrôle, voir
* Suivi.autoriserJournal) pour ne pas écrire une ligne par tick pendant une chute ; mais le verdict qui déclenche
* un SETBACK ou une EXPULSION est toujours écrit si {@code toujoursSanctions} (diagnostic 0.4.0 : l'expulsion
* arrivait sans la ligne du verdict qui l'avait causée). Paresseux : la limite n'est pas consommée pour un
* verdict de sanction écrit d'office.
*/
static boolean ecrireVerdict(Verdict v, boolean toujoursSanctions, BooleanSupplier limiteAutorise) {
if (toujoursSanctions && v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) return true;
return limiteAutorise.getAsBoolean();
}
/** Délai (ms) entre deux lignes d'un même contrôle pour {@code lignesParSeconde} lignes par seconde (au moins 1). */
static long delaiJournalMs(int lignesParSeconde) {
return 1000L / Math.max(1, lignesParSeconde);
}
// --- Sanctions (C2, C4) ---
/** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */
interface Joueur {
UUID id();
String nom();
String dimension();
int tick();
void annoncerTeleport(GraceTeleport.Origine origine);
void teleporter(double x, double y, double z, float yaw, float pitch);
void deconnecter(String message);
void journal(String ligne);
/**
* 0.5 (P1.2) : position au sol juste SOUS le joueur (même x, z ; y du premier bloc solide en dessous, au plus
* 64 blocs), {x, y, z, yaw, pitch}, ou null si rien trouvé ou place insuffisante. Jamais de déplacement
* horizontal : le setback de secours ne peut pas servir à se téléporter.
*/
default double[] solSous() { return null; }
}
/**
* Motif écrit pour une sanction : le contrôle du verdict qui l'a déclenchée (applicable == sanction). Avant 0.4.0
* c'était le premier de la liste, donc un contrôle en OBSERVE (vitesse) pouvait être accusé à la place du vol.
* À défaut, le verdict le plus sévère, puis « anti-triche ».
*/
static String raison(List<Verdict> verdicts, Sanction s) {
Verdict retenu = null;
Verdict auPalier = null;
for (Verdict v : verdicts) {
// 0.5 (P1.3) : plusieurs verdicts au même palier : celui de plus fort VL (avant : le premier, ordre de l'enum).
if (v.applicable() == s && (auPalier == null || v.vl() > auPalier.vl())) auPalier = v;
if (retenu == null || v.applicable().ordinal() > retenu.applicable().ordinal()) retenu = v;
}
if (auPalier != null) return auPalier.controle().id();
return retenu == null ? "anti-triche" : retenu.controle().id();
}
/**
* 0.5 (P1.3) : motif complet pour le journal : le contrôle retenu, puis les autres contrôles au même palier
* (« vol ; aussi : vitesse »). Le message d'expulsion au joueur garde le seul motif retenu.
*/
static String motifJournal(List<Verdict> verdicts, Sanction s) {
String r = raison(verdicts, s);
java.util.LinkedHashSet<String> autres = new java.util.LinkedHashSet<>();
for (Verdict v : verdicts) {
if (v.applicable() == s && !v.controle().id().equals(r)) autres.add(v.controle().id());
}
return autres.isEmpty() ? r : r + " ; aussi : " + String.join(", ", autres);
}
/** Expulsion à usage unique (C4) ; setback vers la position de retour de la même dimension, puis remise à zéro (C2). */
static void appliquerSanction(Moteur moteur, Joueur p, Sanction s, List<Verdict> verdicts) {
String raison = raison(verdicts, s);
String motif = motifJournal(verdicts, s); // P1.3 : journal avec les autres contrôles du palier
if (s == Sanction.EXPULSION) {
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
if (!moteur.expulser(p.id(), p.tick() * 50L)) return;
p.journal(p.nom() + " EXPULSE (" + motif + ")");
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
} else if (s == Sanction.SETBACK) {
if (moteur.setbackDejaApplique(p.id(), p.tick() * 50L)) {
// 0.6.1 (revue M1) : même paquet, second contrôle : pas de second retour ni de second compte.
moteur.apresSetbackDuMemeTick(p.id(), verdicts);
p.journal(p.nom() + " SETBACK deja applique ce tick (" + motif + ") : ni second retour ni second compte");
return;
}
Suivi sv = moteur.suivi(p.id());
double[] sol;
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
p.journal(p.nom() + " SETBACK (" + motif + ")");
} else if (!sv.aPositionValide() && moteur.config().setbackSolSiPasDePosition && (sol = p.solSous()) != null) {
// 0.5 (P1.2) : reconnexion en l'air (aucune position au sol connue) : retour au sol sous le joueur.
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(sol[0], sol[1], sol[2], (float) sol[3], (float) sol[4]);
moteur.apresSetback(p.id(), p.tick() * 50L, verdicts);
p.journal(String.format(java.util.Locale.ROOT, "%s SETBACK au sol (%s) : pas de position de retour, y=%.2f",
p.nom(), motif, sol[1]));
} else {
// 0.5 (P1.1) : avant, rien n'était fait ni écrit (reconnexion en l'air) et le VL montait jusqu'à
// l'expulsion sans trace du setback raté.
String pourquoi = !sv.aPositionValide() ? "pas de position de retour valide"
: "position de retour dans une autre dimension (" + sv.dimension() + ")";
p.journal(p.nom() + " SETBACK impossible (" + motif + ") : " + pourquoi);
}
}
}
}
+564 -46
Voir le fichier
@@ -60,6 +60,10 @@ public final class Garde {
/** Marques propres à un joueur, côté adaptateur (ticks du serveur). */
private static final class Marques {
int teleportTick = Integer.MIN_VALUE;
/** 0.5 (P1.2) : jusqu'à ce tick, grâce de connexion. */
int connexionJusquaTick = Integer.MIN_VALUE;
/** 0.4.0 : jusqu'à ce tick, une fusée a propulsé le joueur (plané non contrôlé). */
int propulsionJusquaTick = Integer.MIN_VALUE;
int reculTick = Integer.MIN_VALUE;
int dernierVerdictTick = Integer.MIN_VALUE;
int dernierTraceTick = Integer.MIN_VALUE;
@@ -77,16 +81,19 @@ public final class Garde {
int vehiculeTick = Integer.MIN_VALUE;
double vehiculeX, vehiculeY, vehiculeZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE;
int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche;
final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
int solServeurTick = Integer.MIN_VALUE;
/** 0.5 (P1.6) : en plané au paquet de mouvement précédent. */
boolean planeAvant;
final Cablage.Elytres elytres = new Cablage.Elytres();
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
int courantTick = Integer.MIN_VALUE;
int courantVuTick = Integer.MIN_VALUE;
boolean courantProche;
final Cablage.CacheDetection courant = new Cablage.CacheDetection();
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
double[] oeilDernier;
double[] oeilAvant;
// 0.6 (scaffold) : rotation des deux derniers paquets de mouvement acceptés
float yawDernier = Float.NaN, pitchDernier, yawAvant = Float.NaN, pitchAvant;
}
/** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */
@@ -142,8 +149,16 @@ public final class Garde {
journal = jeu.resolve("logs").resolve("gastinelgarde.log");
try {
Files.createDirectories(journal.getParent());
ecrireJournal("demarrage GastinelGarde " + GastinelGarde.version()); // 0.5 (P1.4) : version au journal
traces = new TraceFichier(jeu.resolve("gastinelgarde-traces"), GardeSpec.tracesJours(), GardeSpec.tracesTailleOctets());
tracesEnCours = GardeSpec.tracesActives();
// Historique de suspicion : même dossier de jeu que les traces et les journaux (voir HistoriqueSuspicion).
try {
MOTEUR.historique().ouvrir(jeu.resolve("gastinelgarde-suspicion").resolve("incidents.csv"),
System.currentTimeMillis(), CONFIG.suspicionHistoriqueJours);
} catch (IOException | RuntimeException e) {
GastinelGarde.LOGGER.warn("[GastinelGarde] historique de suspicion illisible, repart à vide : {}", e.toString());
}
} catch (IOException e) {
GastinelGarde.LOGGER.error("[GastinelGarde] Impossible d'ouvrir le dossier de traces", e);
traces = null;
@@ -200,6 +215,18 @@ public final class Garde {
m.oeilDernier = null;
}
/** 0.5 (P1.2) : connexion : grâce de connexion (plus longue après une expulsion récente), en plus de la téléportation. */
public static void noterConnexion(ServerPlayer p) {
if (!surThreadServeur(p)) return;
noterTeleport(p);
int tick = p.server.getTickCount();
int grace = MOTEUR.graceConnexionTicks(p.getUUID(), tick * 50L);
marques(p.getUUID()).connexionJusquaTick = tick + grace;
if (grace > CONFIG.graceConnexionTicks) {
ecrireJournal(p.getGameProfile().getName() + " reconnexion apres expulsion recente : grace de " + grace + " ticks");
}
}
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
public static void annoncerTeleport(ServerPlayer p, GraceTeleport.Origine origine) {
if (!surThreadServeur(p)) return;
@@ -336,6 +363,346 @@ public final class Garde {
if (m.graceRecul.recul(tick, autoInflige)) m.reculTick = tick;
}
/** Fusée de feu d'artifice tirée par ce joueur (propulsion en plané) : le plané n'est pas contrôlé pendant 6 s. */
public static void noterFusee(ServerPlayer p, int ticks) {
if (!surThreadServeur(p)) return;
Marques m = marques(p.getUUID());
m.propulsionJusquaTick = Math.max(m.propulsionJusquaTick, p.server.getTickCount() + ticks);
MOTEUR.nouvelleFusee(p.getUUID());
}
/** 0.4.0 : recul appliqué par le serveur (direction du déplacement attendu, force avant résistance). */
public static void noterVelocite(ServerPlayer p, double dirX, double dirZ, double force) {
if (!surThreadServeur(p)) return;
double resistance = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.KNOCKBACK_RESISTANCE);
// Le joueur est-il libre de reculer ? Boîte déplacée de 0,6 puis 1,2 bloc dans le sens du recul : un mur, un trou
// d'un bloc ou un plafond bas (coup d'un tiers qui coince le joueur) annulent la mesure.
double norme = Math.hypot(dirX, dirZ);
boolean libre = norme > 1e-6;
if (libre) {
net.minecraft.world.phys.AABB b = p.getBoundingBox();
double ux = dirX / norme, uz = dirZ / norme;
libre = p.level().noCollision(p, b.move(ux * 0.6, 0, uz * 0.6)) && p.level().noCollision(p, b.move(ux * 1.2, 0, uz * 1.2));
}
MOTEUR.reculApplique(p.getUUID(), p.server.getTickCount() * 50L, dirX, dirZ,
force * Math.max(0.0, 1.0 - resistance), libre);
}
/** 0.4.0 : un totem d'immortalité vient d'éclater (hand = main qui le tenait). */
public static void noterTotem(ServerPlayer p, net.minecraft.world.InteractionHand hand) {
if (!surThreadServeur(p)) return;
net.minecraft.world.InteractionHand autre = hand == net.minecraft.world.InteractionHand.MAIN_HAND
? net.minecraft.world.InteractionHand.OFF_HAND : net.minecraft.world.InteractionHand.MAIN_HAND;
boolean reserve = p.getItemInHand(autre).is(Items.TOTEM_OF_UNDYING);
MOTEUR.totemEclate(p.getUUID(), p.server.getTickCount() * 50L, reserve);
// 0.4.1 : trace de diagnostic (rare : un totem qui eclate) ; explique l'absence de ligne auto-totem ensuite.
ecrireJournal(String.format("%s auto-totem eclatement main=%s reserve=%s mode=%s expulse=%s exempte=%s",
p.getGameProfile().getName(), hand, reserve, CONFIG.mode(Controle.AUTO_TOTEM),
MOTEUR.estExpulse(p.getUUID()), estExempteManuellement(p.getUUID())));
}
/**
* 0.5 (P1.10) : coup critique vanilla accordé à ce joueur. Renvoie vrai si le critique doit être annulé (contrôle
* criticals en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici.
*/
public static boolean noterCritique(ServerPlayer p) {
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID()) || estExempteManuellement(p.getUUID())) return false;
List<Verdict> v = MOTEUR.critique(p.getUUID(), p.server.getTickCount() * 50L, etat(p, true));
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
return Cablage.sanctionDeMouvement(s);
}
/**
* 0.5 (P1.13) : action de casse de bloc reçue (événement LeftClickBlock, vu même annulé). Diagnostic seulement :
* ligne de journal pour un ABORT sans START correspondant (message vanilla « Mismatch in destroy block pos »).
*/
public static void noterActionBloc(ServerPlayer p, boolean start, boolean abort, BlockPos pos, boolean annule) {
// 0.6.1 (revue M2) : bloc visé par un paquet de casse (pour nukerIgnorerCassesSansPaquet).
if (surThreadServeur(p)) MOTEUR.paquetCasse(p.getUUID(), pos.asLong(), p.server.getTickCount() * 50L);
if (!CONFIG.diagnosticActionsBloc || !surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
com.gastinelgarde.core.ActionsBloc a = MOTEUR.suivi(p.getUUID()).actionsBloc;
if (start) {
a.start(pos.getX(), pos.getY(), pos.getZ(), annule);
} else if (abort) {
String ligne = a.abort(pos.getX(), pos.getY(), pos.getZ(), System.currentTimeMillis());
if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne);
}
}
/**
* 0.6.1 (revue M3) : un bloc change (casse ou pose) : noté pour chaque joueur à moins de 16 blocs, dont l'auteur, car
* le client d'un voisin peut encore voir l'ancien bloc (lag) et cliquer dessus.
*/
private static void changementProche(ServerPlayer auteur, BlockPos pos) {
long cle = pos.asLong();
long ms = auteur.server.getTickCount() * 50L;
MOTEUR.changementBloc(auteur.getUUID(), cle, ms);
if (!(auteur.level() instanceof net.minecraft.server.level.ServerLevel niveau)) return;
for (ServerPlayer autre : niveau.players()) {
if (autre != auteur && autre.distanceToSqr(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5) <= 256) {
MOTEUR.changementBloc(autre.getUUID(), cle, ms);
}
}
}
/** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */
public static void noterDebutCasse(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face) {
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ());
// 0.5 (P2.5) : début de casse sans impact : face et portée seulement (journal, expulsion en ENFORCE).
List<Verdict> v = verdictsInteraction(p, pos, face, null, -1);
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
}
/**
* 0.5 (P2.5) : clic droit sur un bloc (main principale). Vrai si l'interaction doit être annulée (interaction-bloc
* en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici. Câblage non testé en jeu.
*/
public static boolean noterInteractionBloc(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) {
if (!surThreadServeur(p)) return false;
// 0.5 (P3, revue) : joueur en cours d'expulsion : interaction annulée (comme les coups, C4). Avant, le doublon
// main secondaire d'un clic qui venait d'expulser se lisait « autorisé ».
if (MOTEUR.estExpulse(p.getUUID())) return true;
autrePaquet(p); // 0.6 (blink)
List<Verdict> v = verdictsInteraction(p, pos, face, impact, mainPrincipale ? 0 : 1);
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
// 0.6.1 (revue M3) : case où ce clic pose un bloc ; si la pose est refusée, le client garde un bloc fantôme.
if (face != null) MOTEUR.changementBloc(p.getUUID(), pos.relative(face).asLong(), p.server.getTickCount() * 50L);
boolean annulerScaffold = poseScaffold(p, pos, face, impact, mainPrincipale);
return Cablage.sanctionDeMouvement(s) || annulerScaffold;
}
/**
* 0.6 (P3.2) : clic droit avec un bloc en main qui posera un bloc de pont sous les pieds. La pose est jugée au paquet
* de mouvement suivant ; vrai si elle doit être annulée (scaffold en ENFORCE, période suspecte). Non testé en jeu.
*/
private static boolean poseScaffold(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) {
if (CONFIG.mode(Controle.SCAFFOLD) == Mode.OFF || impact == null || face == null
|| estExempteManuellement(p.getUUID())) return false;
net.minecraft.world.InteractionHand main = mainPrincipale ? net.minecraft.world.InteractionHand.MAIN_HAND
: net.minecraft.world.InteractionHand.OFF_HAND;
if (!(p.getItemInHand(main).getItem() instanceof net.minecraft.world.item.BlockItem)) return false;
if (!mainPrincipale && p.getMainHandItem().getItem() instanceof net.minecraft.world.item.BlockItem) return false;
BlockPos cible = p.level().getBlockState(pos).canBeReplaced() ? pos : pos.relative(face);
Marques m = marques(p.getUUID());
if (m.oeilDernier == null || m.oeilAvant == null || Float.isNaN(m.yawAvant)) return false;
double dx = m.oeilDernier[0] - m.oeilAvant[0], dz = m.oeilDernier[2] - m.oeilAvant[2];
double dy = m.oeilDernier[1] - m.oeilAvant[1];
if (!com.gastinelgarde.core.Scaffold.estPont(cible.getX(), cible.getY(), cible.getZ(), p.getX(), p.getY(), p.getZ(),
dy, Math.sqrt(dx * dx + dz * dz))) return false;
int tick = p.server.getTickCount();
boolean annuler = MOTEUR.scaffoldAnnuler(p.getUUID(), tick * 50L, tick);
net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
float[] dir = com.gastinelgarde.core.Scaffold.rotation(impact.x - oeil.x, impact.y - oeil.y, impact.z - oeil.z);
MOTEUR.poseScaffold(p.getUUID(), etat(p, true), dir[0], dir[1], m.yawAvant, m.pitchAvant, p.getYRot(), p.getXRot());
return annuler;
}
/** 0.6 (P3.4) : un paquet autre que de mouvement vient d'être traité sur le thread serveur (blink). */
public static void autrePaquet(ServerPlayer p) {
if (!surThreadServeur(p) || CONFIG.mode(Controle.BLINK) == Mode.OFF) return;
MOTEUR.autrePaquet(p.getUUID(), p.server.getTickCount());
}
/** 0.6 (P2.6) : le serveur ouvre (vrai) ou ferme un conteneur pour ce joueur (PlayerContainerEvent). */
public static void noterConteneur(ServerPlayer p, boolean ouvert) {
if (!surThreadServeur(p)) return;
if (ouvert) MOTEUR.ouvrirConteneur(p.getUUID(), p.server.getTickCount());
else MOTEUR.fermerConteneur(p.getUUID());
}
/**
* 0.6 (P2.6) : clic de conteneur (mixin, après ensureRunningOnSameThread). Vrai si le clic doit être ignoré
* (inventaire en ENFORCE au palier SETBACK, ou expulsion en cours) ; le menu est alors renvoyé au client.
*/
public static boolean noterClicConteneur(ServerPlayer p, int idConteneur, int numCase,
net.minecraft.world.inventory.ClickType type) {
if (!surThreadServeur(p)) return false;
if (MOTEUR.estExpulse(p.getUUID())) return true;
autrePaquet(p);
if (CONFIG.mode(Controle.INVENTAIRE) == Mode.OFF || estExempteManuellement(p.getUUID())) return false;
net.minecraft.world.inventory.AbstractContainerMenu menu = p.containerMenu;
boolean idValide = idConteneur == menu.containerId;
boolean menuConteneur = menu != p.inventoryMenu;
boolean caseConteneur = false;
int objet = 0;
if (idValide && numCase >= 0 && numCase < menu.slots.size()) {
net.minecraft.world.inventory.Slot c = menu.getSlot(numCase);
caseConteneur = !(c.container instanceof net.minecraft.world.entity.player.Inventory);
net.minecraft.world.item.ItemStack st = c.getItem();
if (!st.isEmpty()) objet = net.minecraft.core.registries.BuiltInRegistries.ITEM.getId(st.getItem()) + 1;
}
com.gastinelgarde.core.Inventaire.Clic clic = switch (type) {
case QUICK_MOVE, SWAP -> com.gastinelgarde.core.Inventaire.Clic.PRISE;
case THROW -> menuConteneur ? com.gastinelgarde.core.Inventaire.Clic.AUTRE : com.gastinelgarde.core.Inventaire.Clic.PRISE;
default -> com.gastinelgarde.core.Inventaire.Clic.AUTRE;
};
int tick = p.server.getTickCount();
List<Verdict> v = MOTEUR.clicConteneur(p.getUUID(), tick * 50L, tick, etat(p, false), idValide, menuConteneur,
clic, caseConteneur, objet);
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) {
appliquerSanctionMouvement(p, s, v);
return true;
}
if (Cablage.sanctionDeMouvement(s)) {
menu.sendAllDataToRemote(); // le client a prédit le clic : on lui renvoie l'état réel
return true;
}
return false;
}
/**
* 0.6 (P3.5) : paquet de mouvement refusé par vanilla (mixin, juste avant le teleport() de refus). La boîte déclarée
* chevauche-t-elle un bloc solide, alors que celle de la dernière position acceptée est libre ? Non testé en jeu.
*/
public static void refusMouvement(ServerPlayer p, double x, double y, double z) {
if (!surThreadServeur(p) || CONFIG.mode(Controle.PHASE) == Mode.OFF || MOTEUR.estExpulse(p.getUUID())
|| estExempteManuellement(p.getUUID()) || p.isSleeping() || p.isPassenger()) return;
Marques m = marques(p.getUUID());
if (m.mouvementTick == Integer.MIN_VALUE || !Double.isFinite(x + y + z)) return;
double dist = Math.sqrt(Math.pow(x - m.mouvementX, 2) + Math.pow(y - m.mouvementY, 2) + Math.pow(z - m.mouvementZ, 2));
if (dist > 16) return; // lecture de blocs bornée (chunks peut-être non chargés) ; vanilla refuse déjà ce saut
net.minecraft.world.entity.EntityDimensions d = p.getDimensions(p.getPose());
net.minecraft.world.phys.AABB avant = d.makeBoundingBox(m.mouvementX, m.mouvementY, m.mouvementZ).deflate(1.0E-3);
net.minecraft.world.phys.AABB declaree = d.makeBoundingBox(x, y, z).deflate(1.0E-3);
// Déjà coincé dans un bloc (sable tombé, piston) : pas une tentative de phase.
boolean dansBloc = p.level().noCollision(p, avant) && !p.level().noCollision(p, declaree);
int tick = p.server.getTickCount();
List<Verdict> v = MOTEUR.refusPhase(p.getUUID(), tick * 50L, etat(p, true), dansBloc, dist);
Sanction s = traiter(p, v); // vanilla a déjà refusé la position : journal, VL et expulsion seulement
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
}
private static List<Verdict> verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
net.minecraft.world.phys.Vec3 impact, int main) {
if (CONFIG.mode(Controle.INTERACTION_BLOC) == Mode.OFF || estExempteManuellement(p.getUUID())) return List.of();
net.minecraft.world.level.Level l = p.level();
BlockState st = l.getBlockState(pos);
net.minecraft.world.phys.shapes.VoxelShape forme = st.getShape(l, pos);
net.minecraft.world.phys.AABB b = forme.isEmpty() ? new net.minecraft.world.phys.AABB(pos) : forme.bounds().move(pos);
net.minecraft.world.phys.Vec3 oeil = p.getEyePosition();
Marques m = marques(p.getUUID());
double deplacement = 0;
if (m.oeilDernier != null && m.oeilAvant != null) {
deplacement = Math.sqrt(Math.pow(m.oeilDernier[0] - m.oeilAvant[0], 2) + Math.pow(m.oeilDernier[1] - m.oeilAvant[1], 2)
+ Math.pow(m.oeilDernier[2] - m.oeilAvant[2], 2));
}
return MOTEUR.interactionBloc(p.getUUID(), p.server.getTickCount() * 50L, pos.asLong(), main, etat(p, true),
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ},
face == null ? -1 : face.get3DDataValue(), impact == null ? null : new double[] {impact.x, impact.y, impact.z},
st.isAir(), st.isCollisionShapeFullBlock(l, pos), p.blockInteractionRange(), deplacement);
}
/**
* 0.5 (P2.3) : bloc cassé par ce joueur. Renvoie vrai si la casse doit être annulée (fast-break en ENFORCE, palier
* SETBACK ou plus) ; une EXPULSION est appliquée ici.
*/
public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) {
if (!surThreadServeur(p)) return false;
changementProche(p, pos); // 0.6.1 (revue M3) : avant tout retour, pour tous les joueurs proches
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, casse annulée (C4)
if (estExempteManuellement(p.getUUID())) return false;
int tick = p.server.getTickCount();
if (CONFIG.mode(Controle.XRAY) != Mode.OFF) { // 0.5 (P2.10) : alerte seulement
boolean rare = state.is(Blocks.DIAMOND_ORE) || state.is(Blocks.DEEPSLATE_DIAMOND_ORE) || state.is(Blocks.ANCIENT_DEBRIS);
traiter(p, MOTEUR.casseXray(p.getUUID(), tick * 50L, etat(p, false), pos.getY(), rare, rare && expose(p, pos)));
}
boolean annulerNuker = false;
if (CONFIG.mode(Controle.NUKER) != Mode.OFF // 0.5 (P3.3) ; 0.6.1 (M2) : casse en chaîne d'un mod ignorée si réglé
&& !MOTEUR.casseNukerSansPaquet(p.getUUID(), pos.asLong(), tick * 50L)) {
List<Verdict> vn = MOTEUR.casseNuker(p.getUUID(), tick * 50L, tick, etat(p, true));
Sanction sn = traiter(p, vn);
if (sn == Sanction.EXPULSION) {
appliquerSanctionMouvement(p, sn, vn);
return true;
}
annulerNuker = Cablage.sanctionDeMouvement(sn) || MOTEUR.nukerAnnulerCasse(p.getUUID(), tick * 50L, tick);
}
if (CONFIG.mode(Controle.FAST_BREAK) == Mode.OFF) return annulerNuker;
double progression = state.getDestroyProgress(p, p.level(), pos);
List<Verdict> v = MOTEUR.casseBloc(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(),
pos.getZ(), progression);
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
return annulerNuker || Cablage.sanctionDeMouvement(s);
}
/**
* 0.5 (P3.7) : demande de complétion de commande (mixin, après ensureRunningOnSameThread). Vrai si le paquet doit
* être ignoré (completion en ENFORCE et débit dépassé, ou expulsion en cours).
*/
public static boolean noterCompletion(ServerPlayer p) {
if (!surThreadServeur(p)) return false;
autrePaquet(p); // 0.6 (blink)
if (CONFIG.mode(Controle.COMPLETION) == Mode.OFF) return false;
if (MOTEUR.estExpulse(p.getUUID())) return true;
List<Verdict> v = MOTEUR.completion(p.getUUID(), System.currentTimeMillis(), etat(p, false));
Sanction s = traiter(p, v);
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
return MOTEUR.completionAIgnorer(p.getUUID());
}
// 0.5 (P3.1) : tick d'apparition des cristaux de l'End récents (id d'entité -> tick serveur). Thread serveur seulement.
private static final java.util.Map<Integer, Integer> CRISTAUX = new java.util.HashMap<>();
/** 0.5 (P3.1) : un cristal de l'End vient d'apparaître (posé, pas rechargé). */
public static void noterCristal(net.minecraft.world.entity.Entity c, int tick) {
if (c.getServer() != null && !c.getServer().isSameThread()) return;
if (CONFIG.mode(Controle.AUTO_CRISTAL) == Mode.OFF) return;
if (CRISTAUX.size() > 256) {
CRISTAUX.values().removeIf(t -> tick - t > com.gastinelgarde.core.AutoCristal.AGE_MAX_MESURE);
}
CRISTAUX.put(c.getId(), tick);
}
/** 0.5 (P3.1) : âge (ticks) d'un cristal frappé, -1 si son apparition n'a pas été vue. */
public static int ageCristal(net.minecraft.world.entity.Entity c, int tick) {
Integer t = CRISTAUX.remove(c.getId());
if (t == null || tick < t) return -1;
return tick - t;
}
/** 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, BlockPos pos) {
if (!surThreadServeur(p)) return false;
changementProche(p, pos); // 0.6.1 (revue M3)
if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, pose annulée (C4)
if (estExempteManuellement(p.getUUID())) 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 annulerTower || Cablage.sanctionDeMouvement(s);
}
/** 0.5 (P2.10) : une face du bloc touche l'air ou un fluide (minerai visible sans x-ray). */
private static boolean expose(ServerPlayer p, BlockPos pos) {
for (net.minecraft.core.Direction d : net.minecraft.core.Direction.values()) {
BlockPos q = pos.relative(d);
BlockState s = p.level().getBlockState(q);
if (s.isAir() || !p.level().getFluidState(q).isEmpty() || !s.isCollisionShapeFullBlock(p.level(), q)) return true;
}
return false;
}
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
double ms = dureeNs / 1_000_000.0;
if (ms > 250.0) gelTick = server.getTickCount();
@@ -386,12 +753,16 @@ public final class Garde {
mange = anim == UseAnim.EAT || anim == UseAnim.DRINK;
}
// C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect.
m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks);
return EtatJoueur.builder()
.creatif(p.isCreative())
.spectateur(p.isSpectator())
.peutVoler(p.getAbilities().mayfly)
.riptide(riptideRecent)
.elytres(p.isFallFlying())
.elytresDeploiementSuspect(m.elytres.suspectes)
.levitation(p.hasEffect(MobEffects.LEVITATION))
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
.enVehicule(p.isPassenger())
@@ -402,6 +773,8 @@ public final class Garde {
.ticksDepuisGel(depuis(tick, gelTick))
.tps(tpsEstime)
.pingMs(p.connection.latency())
.propulsionRecente(tick <= m.propulsionJusquaTick)
.connexionRecente(tick <= m.connexionJusquaTick)
.build();
}
@@ -470,12 +843,7 @@ public final class Garde {
/** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */
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;
if (m.contraptionProche) m.contraptionVuTick = tick;
}
return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS);
}
/**
@@ -517,8 +885,12 @@ public final class Garde {
marques(p.getUUID()).dernierVerdictTick = p.server.getTickCount();
long maintenant = System.currentTimeMillis();
Suivi suivi = MOTEUR.suivi(p.getUUID());
long delai = Cablage.delaiJournalMs(CONFIG.journalLignesParSeconde);
for (Verdict v : verdicts) {
if (suivi.autoriserJournal(v.controle(), maintenant, 1000)) { // au plus une ligne par seconde et par contrôle
// Au plus journalLignesParSeconde lignes par seconde et par contrôle ; 0.5 (P1.1) : sauf le verdict qui
// déclenche un SETBACK ou une EXPULSION, toujours écrit (journalToujoursSanctions).
if (Cablage.ecrireVerdict(v, CONFIG.journalToujoursSanctions,
() -> suivi.autoriserJournal(v.controle(), maintenant, delai))) {
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());
@@ -526,9 +898,31 @@ public final class Garde {
}
if (v.notifier()) alerterOps(p, v);
}
reagirSuspicion(p);
return Verdict.pire(verdicts);
}
/**
* Score de suspicion (0.4.0) : journal dès « à surveiller », message aux ops dès « suspect ». À « suspect fort »,
* seulement une proposition de sanction à valider dans le Portail : le mod ne sanctionne jamais à partir du score.
*/
private static void reagirSuspicion(ServerPlayer p) {
Moteur.AlerteSuspicion a = MOTEUR.alerteSuspicion(p.getUUID(), System.currentTimeMillis());
if (a == null) return;
String nom = p.getGameProfile().getName();
ecrireJournal(String.format("SUSPICION %s (%s) score=%d niveau=%s incidents7j=%d contributions=[%s]",
nom, p.getUUID(), a.score(), a.niveau(), a.incidents(), a.controles()));
if (a.niveau().ordinal() < com.gastinelgarde.core.Suspicion.Niveau.SUSPECT.ordinal()) return;
String texte = a.niveau() == com.gastinelgarde.core.Suspicion.Niveau.SUSPECT_FORT
? String.format("[Garde] %s : suspect fort (score %d). Proposition de sanction suspect_2, à valider dans le Portail.",
nom, a.score())
: String.format("[Garde] %s : suspect (score %d, %d incident(s) sur 7 jours).", nom, a.score(), a.incidents());
Component msg = Component.literal(texte).withStyle(ChatFormatting.RED);
for (ServerPlayer op : p.server.getPlayerList().getPlayers()) {
if (op.hasPermissions(2) && alertesActivesPour(op.getUUID())) op.sendSystemMessage(msg);
}
}
private static void alerterOps(ServerPlayer cible, Verdict v) {
Component msg = Component.literal(String.format("[Garde] %s : %s VL=%.1f (%s, %s)",
cible.getGameProfile().getName(), v.controle().id(), v.vl(), v.mode(), v.applicable()))
@@ -570,22 +964,29 @@ public final class Garde {
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
public static void avantMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà)
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer
if (estExempteManuellement(p.getUUID())) return;
// F01 : jamais depuis le thread réseau (le mixin l'évite déjà) ; C4 : expulsion en cours, plus rien à évaluer
if (!Cablage.evaluerAvantMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()),
() -> estExempteManuellement(p.getUUID()))) return;
EtatJoueur etat = etat(p, false);
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
Sanction s = traiter(p, v);
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
if (CONFIG.mode(Controle.BLINK) != Mode.OFF) { // 0.6 (P3.4)
int tick = p.server.getTickCount();
List<Verdict> vb = MOTEUR.mouvementBlink(p.getUUID(), tick * 50L, tick, etat, p.isAlive());
Sanction sb = traiter(p, vb);
if (Cablage.sanctionDeMouvement(sb)) appliquerSanctionMouvement(p, sb, vb);
}
}
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
public static void apresMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return;
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
// C4 / C6 : ni évaluation ni état recréé après l'expulsion
if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;
int tick = p.server.getTickCount();
Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p, m);
if (solServeur) m.solServeurTick = tick; // C7
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
@@ -601,9 +1002,13 @@ public final class Garde {
etatMouvement = etat(p, true);
}
if (controler && em != null) {
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em, hauteurPermise(p));
Sanction s = traiter(p, v);
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
// 0.5 (P2) : no-slow… (OBSERVE par défaut). Câblage non testé en jeu.
List<Verdict> v2 = MOTEUR.mouvementP2(p.getUUID(), tick * 50L, etatMouvement, em, faitsMouvement(p));
Sanction s2 = traiter(p, v2);
if (Cablage.sanctionDeMouvement(s2)) appliquerSanctionMouvement(p, s2, v2);
}
// F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
if (!estExempteManuellement(p.getUUID())) {
@@ -619,7 +1024,50 @@ public final class Garde {
// #92 : œil des deux derniers paquets, pour le prochain coup.
m.oeilAvant = m.oeilDernier;
m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z};
// 0.6 : inventaire (rotation avec un conteneur ouvert) et scaffold (pose de pont jugée sur ce regard).
if (CONFIG.mode(Controle.INVENTAIRE) != Mode.OFF) {
if (p.containerMenu == p.inventoryMenu) MOTEUR.fermerConteneur(p.getUUID());
List<Verdict> vi = MOTEUR.regardInventaire(p.getUUID(), tick * 50L, tick, etat(p, false),
p.getYRot(), p.getXRot());
Sanction si = traiter(p, vi);
if (si == Sanction.EXPULSION) appliquerSanctionMouvement(p, si, vi);
}
if (CONFIG.mode(Controle.SCAFFOLD) != Mode.OFF) {
List<Verdict> vs = MOTEUR.regardScaffold(p.getUUID(), tick * 50L, tick, p.getYRot(), p.getXRot());
Sanction ss = traiter(p, vs); // pose déjà faite : les suivantes sont annulées (scaffoldAnnuler)
if (ss == Sanction.EXPULSION) appliquerSanctionMouvement(p, ss, vs);
}
m.yawAvant = m.yawDernier;
m.pitchAvant = m.pitchDernier;
m.yawDernier = p.getYRot();
m.pitchDernier = p.getXRot();
}
// 0.4.0 : recul mesuré (anti-recul) et totem remis en main (auto-totem), sur les mêmes paquets.
if (!estExempteManuellement(p.getUUID()) && (CONFIG.mode(Controle.VELOCITE) != Mode.OFF
|| CONFIG.mode(Controle.AUTO_TOTEM) != Mode.OFF || CONFIG.mode(Controle.AUTO_TOTEM_REGULIER) != Mode.OFF)) {
EtatJoueur etatSup = etat(p, true);
long maintenant = tick * 50L;
if (m.mouvementTick != Integer.MIN_VALUE) {
// milieuSpecial toujours calculé ici, indépendamment de em (nul quand vol/vitesse/no-fall sont coupés).
List<Verdict> v = MOTEUR.mesureRecul(p.getUUID(), maintenant, etatSup, p.getX() - m.mouvementX,
p.getZ() - m.mouvementZ, milieuSpecial(p, m, tick), (ux, uz) -> !p.level().noCollision(p,
p.getBoundingBox().move(ux * 0.3, 0, uz * 0.3)));
Sanction sv = traiter(p, v); // 0.4.2 : setback (retour en arrière) ou expulsion en ENFORCE
if (Cablage.sanctionDeMouvement(sv)) appliquerSanctionMouvement(p, sv, v);
}
boolean totem = p.getMainHandItem().is(Items.TOTEM_OF_UNDYING) || p.getOffhandItem().is(Items.TOTEM_OF_UNDYING);
List<Verdict> vt = MOTEUR.totemEnMain(p.getUUID(), maintenant, etatSup, totem);
Sanction st = traiter(p, vt); // 0.4.2 : expulsion en ENFORCE (le palier SETBACK reste une alerte)
if (st == Sanction.EXPULSION) appliquerSanctionMouvement(p, st, vt);
}
// 0.5 (P1.6) : passage en plané depuis le paquet précédent (ElytraFly « packet » : bascule permanente).
boolean plane = p.isFallFlying();
if (plane && !m.planeAvant && !estExempteManuellement(p.getUUID())) {
List<Verdict> vd = MOTEUR.deploiementElytres(p.getUUID(), tick * 50L, etat(p, false));
traiter(p, vd); // OBSERVE en production ; en ENFORCE, l'expulsion seulement
if (Verdict.pire(vd) == Sanction.EXPULSION) appliquerSanctionMouvement(p, Sanction.EXPULSION, vd);
}
m.planeAvant = plane;
m.mouvementTick = tick;
m.mouvementX = p.getX();
m.mouvementY = p.getY();
@@ -628,8 +1076,8 @@ public final class Garde {
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée
// qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
if (m.dernierVerdictTick != tick && !vehiculeControle(p)
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) {
if (Cablage.memoriserRetour(MOTEUR, m.dernierVerdictTick, tick, () -> vehiculeControle(p), solServeur,
em != null && em.milieuSpecial())) {
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
p.level().dimension().location().toString());
}
@@ -765,7 +1213,52 @@ public final class Garde {
private static boolean mouvementControlesActifs() {
return CONFIG.mode(Controle.NO_FALL) != Mode.OFF || CONFIG.mode(Controle.VITESSE) != Mode.OFF
|| CONFIG.mode(Controle.VOL) != Mode.OFF;
|| CONFIG.mode(Controle.VOL) != Mode.OFF || CONFIG.mode(Controle.STEP) != Mode.OFF
|| CONFIG.mode(Controle.ANTI_FAIM) != Mode.OFF || CONFIG.mode(Controle.NO_SLOW) != Mode.OFF
|| CONFIG.mode(Controle.JESUS) != Mode.OFF || CONFIG.mode(Controle.OMNISPRINT) != Mode.OFF
|| CONFIG.mode(Controle.CRITICALS) != Mode.OFF; // criticals : suit la hauteur à chaque mouvement
}
/** 0.5 (P2) : faits supplémentaires du paquet accepté pour {@link Moteur#mouvementP2}. */
private static com.gastinelgarde.core.FaitsMouvement faitsMouvement(ServerPlayer p) {
return new com.gastinelgarde.core.FaitsMouvement()
.ticksUsage(p.isUsingItem() ? p.getTicksUsingItem() : -1)
.fluide(CONFIG.mode(Controle.JESUS) != Mode.OFF && surFluide(p), CONFIG.mode(Controle.JESUS) != Mode.OFF && entiteSolideSous(p))
.direction(p.getX() - marques(p.getUUID()).mouvementX, p.getZ() - marques(p.getUUID()).mouvementZ, p.getYRot());
}
/** 0.5 (P2.11) : fluide au bloc des pieds ou juste dessous (pieds à moins d'un bloc au-dessus de sa surface). */
private static boolean surFluide(ServerPlayer p) {
net.minecraft.world.level.Level l = p.level();
BlockPos pieds = BlockPos.containing(p.getX(), p.getY() - 0.05, p.getZ());
return !l.getFluidState(pieds).isEmpty() || !l.getFluidState(pieds.below()).isEmpty() && p.getY() - pieds.getY() < 0.2;
}
/** 0.5 (P2.11) : bateau, shulker, minecart… (entité sur laquelle on peut se tenir) ou vaisseau Sable sous les pieds. */
private static boolean entiteSolideSous(ServerPlayer p) {
if (SableAcces.surSousNiveau(p)) return true;
net.minecraft.world.phys.AABB b = p.getBoundingBox();
net.minecraft.world.phys.AABB sous = new net.minecraft.world.phys.AABB(b.minX - 0.1, b.minY - 0.6, b.minZ - 0.1,
b.maxX + 0.1, b.minY + 0.1, b.maxZ + 0.1);
return !p.level().getEntities(p, sous, e -> e.canBeCollidedWith() || e instanceof net.minecraft.world.entity.vehicle.VehicleEntity).isEmpty();
}
/**
* 0.5 (P1.9) : hauteur de marche permise en un tick : max(attribut step_height, puissance de saut = jump_strength
* + Saut amélioré). NaN (pas de mesure step) si un piston en mouvement touche la boîte du joueur élargie d'un
* bloc : un piston peut soulever un joueur d'un bloc entre deux paquets [À VÉRIFIER en jeu].
*/
private static double hauteurPermise(ServerPlayer p) {
if (CONFIG.mode(Controle.STEP) == Mode.OFF) return Double.NaN;
net.minecraft.world.phys.AABB b = p.getBoundingBox().inflate(1.0);
for (BlockPos q : BlockPos.betweenClosed(net.minecraft.util.Mth.floor(b.minX), net.minecraft.util.Mth.floor(b.minY),
net.minecraft.util.Mth.floor(b.minZ), net.minecraft.util.Mth.floor(b.maxX),
net.minecraft.util.Mth.floor(b.maxY), net.minecraft.util.Mth.floor(b.maxZ))) {
if (p.level().getBlockState(q).is(Blocks.MOVING_PISTON)) return Double.NaN;
}
double marche = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.STEP_HEIGHT);
double saut = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.JUMP_STRENGTH) + p.getJumpBoostPower();
return Math.max(marche, saut);
}
/**
@@ -849,12 +1342,7 @@ public final class Garde {
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */
private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) {
m.courantProche = courantAir(p);
m.courantTick = tick;
if (m.courantProche) m.courantVuTick = tick;
}
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS);
}
/**
@@ -895,23 +1383,53 @@ public final class Garde {
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) {
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return;
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")");
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ")."));
} else if (s == Sanction.SETBACK) {
Suivi sv = MOTEUR.suivi(p.getUUID());
String dim = p.level().dimension().location().toString();
if (sv.aPositionValide() && sv.dimension().equals(dim)) {
annoncerTeleport(p, GraceTeleport.Origine.SETBACK);
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
/** Profondeur maximale (blocs) de la recherche du sol sous le joueur (setback de secours, P1.2). */
private static final int SOL_SOUS_MAX_BLOCS = 64;
/**
* 0.5 (P1.2) : sol juste sous le joueur, même x et z : premier bloc à forme de collision non vide (ou fluide) en
* descendant, au plus 64 blocs, avec la place pour la boîte du joueur. Null sinon (vide, hors du monde).
*/
static double[] solSous(ServerPlayer p) {
net.minecraft.world.level.Level l = p.level();
BlockPos.MutableBlockPos q = p.blockPosition().mutable();
for (int i = 0; i <= SOL_SOUS_MAX_BLOCS && q.getY() >= l.getMinBuildHeight(); i++, q.move(0, -1, 0)) {
if (!l.hasChunkAt(q)) return null;
BlockState s = l.getBlockState(q);
double y;
if (!l.getFluidState(q).isEmpty()) {
y = q.getY(); // eau / lave : dans le fluide, la chute s'arrête ou ralentit
} else {
net.minecraft.world.phys.shapes.VoxelShape forme = s.getCollisionShape(l, q);
if (forme.isEmpty()) continue;
y = q.getY() + forme.max(net.minecraft.core.Direction.Axis.Y);
}
if (y > p.getY() + 1e-6) return null; // jamais vers le haut
net.minecraft.world.phys.AABB b = p.getBoundingBox().move(0, y - p.getY(), 0);
if (!l.noCollision(p, b)) return null;
return new double[] {p.getX(), y, p.getZ(), p.getYRot(), p.getXRot()};
}
return null;
}
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
}
/** Adaptateur ServerPlayer de Cablage.appliquerSanction. */
private static Cablage.Joueur joueur(ServerPlayer p) {
return new Cablage.Joueur() {
@Override public UUID id() { return p.getUUID(); }
@Override public String nom() { return p.getGameProfile().getName(); }
@Override public String dimension() { return p.level().dimension().location().toString(); }
@Override public int tick() { return p.server.getTickCount(); }
@Override public void annoncerTeleport(GraceTeleport.Origine origine) { Garde.annoncerTeleport(p, origine); }
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
p.connection.teleport(x, y, z, yaw, pitch);
}
@Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
@Override public void journal(String ligne) { ecrireJournal(ligne); }
@Override public double[] solSous() { return Garde.solSous(p); }
};
}
}
+11
Voir le fichier
@@ -137,6 +137,17 @@ public final class GardeAntiCrash {
if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
Vec3 v = cart.getDeltaMovement();
// C18 : avec l'option, un minecart contenant immobile (stockage) n'est pas cassé.
boolean contenant = cart instanceof net.minecraft.world.Container;
if (!AntiCrashEntites.empilementACasser(n, r, v.length(), contenant)) {
if (plafonnementASignaler(cart.getUUID())) {
Garde.journaliser(String.format(java.util.Locale.ROOT,
"anti-crash EMPILEMENT %s immobile garde (%d minecarts superposés > %d), dim=%s pos=(%.1f, %.1f, %.1f)",
BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()), n, r.empilementMax,
cart.level().dimension().location(), cart.getX(), cart.getY(), cart.getZ()));
}
return false;
}
cart.destroy(cart.getPickResult().getItem());
String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
String ligne = String.format(java.util.Locale.ROOT,
+3 -1
Voir le fichier
@@ -73,7 +73,7 @@ public final class GardeCommands {
private static int status(CommandContext<CommandSourceStack> ctx) {
GardeConfig c = Garde.config();
StringBuilder sb = new StringBuilder("GastinelGarde :");
StringBuilder sb = new StringBuilder("GastinelGarde " + GastinelGarde.version() + " :");
for (Controle k : Controle.values()) sb.append("\n ").append(k.id()).append(" = ").append(c.mode(k));
sb.append("\n sanction max = ").append(c.sanctionMax)
.append(" | traces = ").append(Garde.tracesEnCours() ? "on" : "off")
@@ -91,6 +91,8 @@ public final class GardeCommands {
sb.append("\n ").append(k.id()).append(" VL=")
.append(String.format(java.util.Locale.ROOT, "%.1f", suivi.vl.valeur(k, now)));
}
sb.append(String.format(java.util.Locale.ROOT, "\n suspicion = %.0f (%s)", Garde.moteur().scoreSuspicion(p.getUUID()),
suivi.suspicion.niveau(System.currentTimeMillis())));
if (Garde.estExempteManuellement(p.getUUID())) sb.append("\n (exempté manuellement)");
ok(ctx, sb.toString());
return 1;
+128 -13
Voir le fichier
@@ -57,11 +57,17 @@ public final class GardeEvents {
@SubscribeEvent
public static void onAttaque(AttackEntityEvent event) {
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours
event.setCanceled(true);
return;
Garde.autrePaquet(p); // 0.6 (blink) : un coup est un paquet traité sur le thread serveur
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 -> { }
}
if (Garde.estExempteManuellement(p.getUUID())) return;
Entity cible = event.getTarget();
int tick = p.server.getTickCount();
@@ -83,8 +89,9 @@ public final class GardeEvents {
// (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 = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible)
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
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
@@ -102,12 +109,74 @@ public final class GardeEvents {
visible ? null : "non-visible"));
}
Sanction s = Garde.traiter(p, verdicts);
if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE
if (s.ordinal() >= Sanction.SETBACK.ordinal()) {
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
// 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();
Garde.autrePaquet(p); // 0.6 (blink)
// 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.getPos())) event.setCanceled(true);
}
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
@@ -125,7 +194,11 @@ public final class GardeEvents {
@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);
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). */
@@ -135,13 +208,55 @@ public final class GardeEvents {
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());
}
}
/** 0.6 (P2.6) : conteneur ouvert / fermé côté serveur (inventaire : réaction, rotation écran ouvert). */
@SubscribeEvent
public static void onOuvertureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Open event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, true);
}
@SubscribeEvent
public static void onFermetureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Close event) {
if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, false);
}
@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.noterTeleport(p);
Garde.noterConnexion(p); // téléportation + 0.5 (P1.2) grâce de connexion
}
}
+357 -3
Voir le fichier
@@ -22,6 +22,29 @@ public final class GardeSpec {
private static final ModConfigSpec.DoubleValue SEUIL_EXPULSION;
private static final ModConfigSpec.EnumValue<Sanction> SANCTION_MAX;
private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS, SETBACK_SOL, DIAG_ACTIONS;
private static final ModConfigSpec.IntValue GRACE_CONNEXION, GRACE_APRES_EXPULSION;
private static final ModConfigSpec.DoubleValue STEP_HAUTEUR, STEP_MARGE, CRIT_MICRO;
private static final ModConfigSpec.IntValue CRIT_SERIE, ANTI_FAIM_TICKS, ELY_DEPLOIEMENTS;
private static final ModConfigSpec.IntValue JOURNAL_LIMITE;
// 0.5 (P2)
private static final ModConfigSpec.DoubleValue NO_SLOW_FACTEUR;
private static final ModConfigSpec.IntValue NO_SLOW_GRACE, NO_SLOW_TICKS, JESUS_TICKS, OMNI_TICKS;
private static final ModConfigSpec.DoubleValue OMNI_ANGLE, XRAY_PCT, XRAY_CACHES;
private static final ModConfigSpec.IntValue XRAY_Y, XRAY_RARES;
private static final ModConfigSpec.DoubleValue FAST_BREAK_FACTEUR;
private static final ModConfigSpec.IntValue FAST_BREAK_TICKS_MIN, FAST_BREAK_SERIE;
private static final ModConfigSpec.IntValue FAST_PLACE_SERIE, FAST_PLACE_INTERVALLE;
private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE, INTER_MARGE;
private static final ModConfigSpec.IntValue INTER_GRACE;
private static final ModConfigSpec.BooleanValue NUKER_SANS_PAQUET;
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, TOWER_INTERVALLE, TOWER_SERIE,
COMPLETION_PAR_S, COMPLETION_RAFALE;
/** 0.6 : réglages des sections [inventaire], [scaffold], [blink], [phase] ; clé = nom du champ de GardeConfig. */
private static final java.util.Map<String, ModConfigSpec.ConfigValue<?>> V06 = new java.util.LinkedHashMap<>();
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
private static final ModConfigSpec.IntValue CIBLES_MAX;
private static final ModConfigSpec.IntValue FENETRE_CIBLES_MS;
@@ -50,9 +73,19 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX, TIMER_DETTE_MAX;
private static final ModConfigSpec.IntValue ELY_MONTEE, ELY_STATIONNAIRE, VEL_FENETRE, VEL_SERIE, TOTEM_DELAI, TOTEM_PING;
private static final ModConfigSpec.DoubleValue VEL_RAPPORT, VEL_FORCE, VEL_POINTS, TOTEM_SEUIL_SB, TOTEM_SEUIL_EXP, VEL_SEUIL_SB, VEL_SEUIL_EXP;
private static final ModConfigSpec.BooleanValue SUSP_ACTIVE;
private static final ModConfigSpec.DoubleValue SUSP_SURVEILLER, SUSP_SUSPECT, SUSP_FORT, SUSP_DEMI_VIE,
SUSP_PLAFOND_FIABLE, SUSP_PLAFOND_MOYEN, SUSP_PLAFOND_FAIBLE, SUSP_DIVERSITE_FENETRE;
private static final ModConfigSpec.IntValue SUSP_DIVERSITE, SUSP_JOURS, VOL_FLOTTEMENT;
private static final ModConfigSpec.BooleanValue VOL_FENETRE_GLISSANTE;
private static final ModConfigSpec.BooleanValue VITESSE_MOYENNE;
private static final ModConfigSpec.BooleanValue ELYTRES_STRICTE;
private static final ModConfigSpec.IntValue ELYTRES_AIR_MIN;
private static final ModConfigSpec.BooleanValue COMBAT_VEHICULE;
private static final ModConfigSpec.BooleanValue AC_EMPILEMENT_MOUVEMENT;
private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
private static final ModConfigSpec.IntValue SERIE_COUPS;
@@ -100,6 +133,13 @@ public final class GardeSpec {
.defineEnum("sanctionMax", Sanction.EXPULSION);
b.pop();
b.comment("0.5 : journal logs/gastinelgarde.log.").push("journal");
JOURNAL_TOUJOURS = b.comment("Le verdict qui déclenche un SETBACK ou une EXPULSION est toujours écrit, malgré la limite ci-dessous.")
.define("toujoursEcrireSanctions", true);
JOURNAL_LIMITE = b.comment("Lignes au plus par seconde et par contrôle (évite une ligne par tick pendant une chute).")
.defineInRange("limiteLignesParSeconde", 1, 1, 20);
b.pop();
b.push("combat");
ANGLE_MAX = b.comment("Excédent d'angle maximal entre le regard et la silhouette de la cible (degrés).")
.defineInRange("angleMaxDegres", 60.0, 5.0, 180.0);
@@ -121,6 +161,11 @@ public final class GardeSpec {
.defineInRange("pingLatenceMaxMs", 300, 0, 1000);
VITESSE_CIBLE_MAX = b.comment("Cible plus rapide (blocs/tick) : portée et hitbox ne mesurent pas (élytres, recul, téléportation).")
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
CRIT_MICRO = b.comment("0.5 (P1.10) criticals : critique suspect si, depuis le dernier « au sol » du client, le joueur n'est ni monté",
"ni descendu de plus de cette valeur (blocs). Vrai saut : ~1,25 ; micro-saut de cheat : 0,0625.")
.defineInRange("criticalsMicroSautMax", 0.1, 0.01, 1.0);
CRIT_SERIE = b.comment("Criticals : critiques suspects, parmi les 10 derniers en 60 s, avant qu'un critique suspect compte.")
.defineInRange("criticalsSerieMin", 3, 1, 10);
b.pop();
b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu",
@@ -147,11 +192,71 @@ public final class GardeSpec {
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
"0 = désactivé (défaut). Essai conseillé : 20, en OBSERVE.")
.defineInRange("timerSoldeMax", 0, 0, 1000);
"0 = désactivé. 0.5 : 20 par défaut (un fichier existant garde sa valeur).")
.defineInRange("timerSoldeMax", 20, 0, 1000);
TIMER_DETTE_MAX = b.comment("0.5 : crédit au plus (paquets en retard pendant un lag) remboursable par la rafale de rattrapage.")
.defineInRange("timerDetteMax", 40, 0, 1000);
b.pop();
b.comment("Score de suspicion de 0 à 100 par joueur (0.4.0). INFORMATION POUR LES HUMAINS : aucune sanction n'en découle.",
"Chaque contrôle (même en OBSERVE) contribue (VL / seuilExpulsion, au plus 1) x son plafond selon sa fiabilité ;",
"le pic décroît avec une demi-vie. Journal dès seuilSurveiller ; message aux ops dès seuilSuspect ;",
"dès seuilFort, proposition de sanction suspect_2 à valider dans le Portail (jamais appliquée par le mod).")
.push("suspicion");
SUSP_ACTIVE = b.define("actif", true);
SUSP_SURVEILLER = b.defineInRange("seuilSurveiller", 25.0, 1.0, 100.0);
SUSP_SUSPECT = b.defineInRange("seuilSuspect", 50.0, 1.0, 100.0);
SUSP_FORT = b.defineInRange("seuilFort", 75.0, 1.0, 100.0);
SUSP_DEMI_VIE = b.comment("Demi-vie du score, en minutes de jeu (le suivi est libéré à la déconnexion).")
.defineInRange("demiVieMinutes", 10.0, 0.5, 1440.0);
SUSP_PLAFOND_FIABLE = b.comment("Plafond de contribution : vol, vitesse, no-fall, portee, hitbox, regularite.")
.defineInRange("plafondFiable", 50.0, 0.0, 100.0);
SUSP_PLAFOND_MOYEN = b.comment("Plafond : coups-hors-boite, killaura-angle, killaura-cibles, cadence.")
.defineInRange("plafondMoyen", 30.0, 0.0, 100.0);
SUSP_PLAFOND_FAIBLE = b.comment("Plafond : timer, rotation, attaque-impossible, vehicule-vitesse, vehicule-vol (faux positifs).")
.defineInRange("plafondFaible", 15.0, 0.0, 100.0);
SUSP_DIVERSITE = b.comment("Ce nombre de contrôles distincts au palier SETBACK dans la fenêtre = suspect fort ; 0 = coupé.")
.defineInRange("diversiteControles", 3, 0, 20);
SUSP_DIVERSITE_FENETRE = b.defineInRange("diversiteFenetreMinutes", 10.0, 0.5, 1440.0);
SUSP_JOURS = b.comment("Historique des incidents par UUID (gastinelgarde-suspicion/incidents.csv), en jours.")
.defineInRange("historiqueJours", 7, 1, 365);
b.pop();
b.comment("0.4.0 : plané en élytres (Elytra Hack), recul absent après un coup subi (Anti Knockback / Anti Push),",
"totem remis en main sans délai humain (Auto Totem). Contrôles 'elytres', 'velocite' et 'auto-totem' : OBSERVE par défaut.")
.push("nouveauxControles");
ELY_MONTEE = b.comment("Ticks de montée sans perte de vitesse en plané avant infraction ; 0 = coupé.")
.defineInRange("elytresMonteeTicks", 20, 0, 600);
ELY_STATIONNAIRE = b.comment("Ticks de plané presque immobile sans chute avant infraction ; 0 = coupé.")
.defineInRange("elytresStationnaireTicks", 20, 0, 600);
ELY_DEPLOIEMENTS = b.comment("0.5 (P1.6) : déploiements d'élytres au plus par seconde ; au-delà, ElytraFly « packet » (un START_FALL_FLYING",
"pendant le plané l'arrête, le suivant le relance). 0 = coupé.")
.defineInRange("elytresDeploiementsMax", 5, 0, 20);
VEL_FENETRE = b.defineInRange("velociteFenetreTicks", 6, 2, 20);
VEL_RAPPORT = b.comment("Recul absent si le déplacement dans le sens du recul est sous cette part du recul vanilla.")
.defineInRange("velociteRapportMin", 0.15, 0.0, 1.0);
VEL_SERIE = b.comment("Reculs absents (sur les 6 derniers en 2 minutes) avant infraction.")
.defineInRange("velociteSerieMin", 3, 1, 6);
VEL_FORCE = b.defineInRange("velociteForceMin", 0.15, 0.0, 5.0);
VEL_POINTS = b.comment("0.4.1 : points ajoutes par recul absent (en serie). 4 : 6 reculs absents espaces de 3 s depassent le SETBACK (10).")
.defineInRange("velocitePoints", 4.0, 0.0, 20.0);
TOTEM_SEUIL_SB = b.comment("0.4.2 : seuils propres (0 = seuil global de [sanctions]). Auto-totem : le palier SETBACK reste une alerte.")
.defineInRange("autoTotemSeuilSetback", 0.0, 0.0, 1000.0);
TOTEM_SEUIL_EXP = b.comment("Auto-totem : expulsion en ENFORCE (9 = trois detections rapprochees a +3).")
.defineInRange("autoTotemSeuilExpulsion", 9.0, 0.0, 1000.0);
VEL_SEUIL_SB = b.comment("Velocite : retour en arriere (setback) en ENFORCE.")
.defineInRange("velociteSeuilSetback", 8.0, 0.0, 1000.0);
VEL_SEUIL_EXP = b.comment("Velocite : expulsion en ENFORCE.")
.defineInRange("velociteSeuilExpulsion", 16.0, 0.0, 1000.0);
TOTEM_DELAI = b.comment("Réaction humaine minimale (ms) entre l'éclatement et le totem remis en main, ping en plus.")
.defineInRange("totemDelaiMinMs", 150, 0, 2000);
TOTEM_PING = b.defineInRange("totemPingMaxMs", 200, 0, 1000);
b.pop();
b.push("mouvement");
VOL_FLOTTEMENT = b.comment("Vol : ticks consécutifs en l'air sans chute avant infraction (vanilla : 80, 'kicked for floating too long').",
"Remplace ce contrôle vanilla si allow-flight=true. 0 = coupé.")
.defineInRange("volFlottementTicks", 80, 0, 1200);
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);
@@ -161,6 +266,168 @@ public final class GardeSpec {
VITESSE_MOYENNE = b.comment("C15 : vitesse moyenne sur 40 paquets comparée à la moyenne vanilla (course, sprint-saut).",
"Désactivé par défaut : à essayer en OBSERVE (fausse alerte possible sous un plafond bas, C16).")
.define("vitesseMoyenne", false);
ELYTRES_STRICTE = b.comment("C7 : plané déclenché sans ticks en l'air (sol serveur) = pas d'exemption de mouvement ;",
"portée et hitbox mesurées pendant le plané. Désactivé par défaut : à essayer en OBSERVE.")
.define("elytresExemptionStricte", false);
ELYTRES_AIR_MIN = b.comment("C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres.")
.defineInRange("elytresAirMinTicks", 2, 1, 20);
COMBAT_VEHICULE = b.comment("C8 : le combat d'un passager de véhicule (bateau, cheval, minecart) est mesuré comme à pied.",
"Désactivé par défaut : à essayer en OBSERVE (portée, hitbox, killaura).")
.define("combatMesureEnVehicule", false);
STEP_HAUTEUR = b.comment("0.5 (P1.9) step : hauteur de marche au moins permise en un tick (vanilla : attribut step_height 0,6).",
"L'attribut réel du joueur et sa puissance de saut (0,42 + Saut amélioré) relèvent le seuil.")
.defineInRange("stepHauteurMax", 0.6, 0.5, 10.0);
STEP_MARGE = b.comment("Step : marge (blocs) au-dessus de la hauteur permise.")
.defineInRange("stepMargeBlocs", 0.1, 0.0, 2.0);
ANTI_FAIM_TICKS = b.comment("0.5 (P1.8) anti-faim : paquets consécutifs de course au sol (vu par le serveur, sans déplacement vertical)",
"déclarée « en l'air » par le client avant infraction. Vanilla ne compte la faim de course qu'au sol.")
.defineInRange("antiFaimTicks", 20, 5, 1200);
OMNI_ANGLE = b.comment("0.5 (P2.14) omnisprint : angle (degrés) déplacement / regard au-delà duquel un sprint est impossible en vanilla",
"(le sprint s'arrête sans entrée vers l'avant).")
.defineInRange("omnisprintAngleDegres", 100.0, 60.0, 180.0);
OMNI_TICKS = b.comment("Omnisprint : paquets consécutifs au sol avant infraction.")
.defineInRange("omnisprintTicks", 10, 3, 200);
JESUS_TICKS = b.comment("0.5 (P2.11) jesus : paquets consécutifs « au sol » (client) sur un fluide, sans bloc ni entité dessous, sans chute.")
.defineInRange("jesusTicks", 10, 3, 200);
NO_SLOW_FACTEUR = b.comment("0.5 (P2.1) no-slow : vitesse au sol permise en utilisant un objet = ce facteur × course (0,30 bloc/tick) × effets.",
"Vanilla ralentit à ×0,2 (≈0,06 bloc/tick en courant) : 0,5 laisse une marge large.")
.defineInRange("noSlowFacteur", 0.5, 0.2, 2.0);
NO_SLOW_GRACE = b.comment("No-slow : ticks d'usage d'objet avant de mesurer (élan de la course).")
.defineInRange("noSlowGraceTicks", 3, 0, 40);
NO_SLOW_TICKS = b.comment("No-slow : paquets suspects consécutifs avant infraction.")
.defineInRange("noSlowTicks", 10, 2, 200);
b.pop();
b.comment("0.5 (P2) : casse et pose de blocs. Nouveaux contrôles en OBSERVE par défaut.").push("monde");
FAST_BREAK_FACTEUR = b.comment("0.5 (P2.3) fast-break : rapport (progression par tick × ticks depuis le START) sous lequel une casse est suspecte.",
"Vanilla accepte la casse dès 0,7 ; un client honnête casse vers 1,0.")
.defineInRange("fastBreakFacteur", 0.8, 0.7, 1.0);
FAST_BREAK_TICKS_MIN = b.comment("Fast-break : blocs plus rapides que ce nombre de ticks non mesurés.")
.defineInRange("fastBreakTicksMin", 6, 2, 200);
FAST_BREAK_SERIE = b.comment("Fast-break : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter.")
.defineInRange("fastBreakSerieMin", 4, 1, 10);
FAST_PLACE_SERIE = b.comment("0.5 (P2.4) fast-place : intervalles entre poses examinés (poses du même tick regroupées).",
"Les clics rapides humains (drag-click) dépassent 20/s mais jamais avec une régularité au tick près.")
.defineInRange("fastPlaceSerie", 40, 5, 64);
FAST_PLACE_REGULARITE = b.comment("Fast-place : part des intervalles qui valent exactement le même nombre de ticks.")
.defineInRange("fastPlaceRegularite", 0.9, 0.5, 1.0);
FAST_PLACE_INTERVALLE = b.comment("Fast-place : cet intervalle commun (ticks) au plus. Vanilla au clic maintenu : 4. 2 = attrape aussi le délai 1.")
.defineInRange("fastPlaceIntervalleMaxTicks", 1, 1, 3);
INTER_MARGE = b.comment("0.5 (P2.5) interaction-bloc : marge (blocs) de portée et de face cachée, en plus du déplacement du dernier tick.",
"Signale : clic sur de l'air (AirPlace), face vue de derrière, impact hors de la face d'un bloc plein, portée de bloc.")
.defineInRange("interactionBlocMarge", 0.5, 0.0, 3.0);
TOTEM_ECHANT = b.comment("0.5 (P2.7) auto-totem-regulier : délais éclatement -> totem en main examinés (section [monde] par commodité).")
.defineInRange("autoTotemEchantillons", 5, 3, 16);
TOTEM_ECART = b.comment("Auto-totem-regulier : écart type (ms) sous lequel ces délais sont ceux d'une machine (délais quantifiés à 50 ms).")
.defineInRange("autoTotemEcartTypeMinMs", 30, 0, 500);
TOTEM_REG_MAX = b.comment("Auto-totem-regulier : tous les délais examinés sous cette valeur (ms).")
.defineInRange("autoTotemRegulierMaxMs", 300, 50, 2000);
INTER_SERIE = b.comment("Interaction-bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter.")
.defineInRange("interactionBlocSerieMin", 3, 1, 10);
INTER_GRACE = b.comment("0.6.1 (revue M3) interaction-bloc : un clic sur un bloc devenu de l'air depuis moins de ce délai (ms)",
"(casse, pose ou pose refusée : bloc fantôme côté client) ne compte pas comme « bloc-vide ».")
.defineInRange("interactionBlocGraceChangementMs", 500, 0, 5000);
b.pop();
b.comment("0.5 (P3) : contrôles lourds. Nouveaux contrôles en OBSERVE par défaut, valeurs prudentes.").push("p3");
NUKER_MAX = b.comment("0.5 (P3.3) nuker : blocs cassés par un joueur dans un même tick serveur au-delà desquels le tick est suspect.",
"Vanilla : 1 par tick client ; 3 couvre les paquets groupés par la gigue réseau. Un mod d'abattage / de minage de filon",
"côté serveur casse aussi plusieurs blocs au nom du joueur : à vérifier avant tout ENFORCE.")
.defineInRange("nukerBlocsParTickMax", 3, 1, 64);
NUKER_SERIE = b.comment("Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter.")
.defineInRange("nukerSerieMin", 3, 1, 20);
NUKER_SANS_PAQUET = b.comment("0.6.1 (revue M2) nuker : true = ne compter que les casses visées par un paquet de casse du joueur",
"dans le même tick (ignore les blocs cassés en chaîne par un mod d'abattage d'arbres ou de minage de filon).",
"false par défaut (aucun mod de ce genre sur le serveur). Un nuker de client triche envoie un paquet par bloc : il reste vu.")
.define("nukerIgnorerCassesSansPaquet", false);
CRISTAL_DELAI = b.comment("0.5 (P3.1) auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect.",
"2 = frappé dans le tick de sa pose ou le suivant. Cristaux d'âge inconnu (rechargés, posés avant) non mesurés.",
"Risque de faux positif élevé (PvP cristal rapide, paquets groupés) : longue observation avant tout ENFORCE.")
.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);
COMPLETION_PAR_S = b.comment("0.5 (P3.7) completion : demandes de complétion de commande par seconde soutenues permises.",
"Vanilla analyse chaque demande sans limite de débit ; le client vanilla en envoie une par frappe. En ENFORCE l'excès est ignoré.")
.defineInRange("completionParSecondeMax", 20, 5, 1000);
COMPLETION_RAFALE = b.comment("Completion : rafale permise (capacité du seau à jetons).")
.defineInRange("completionRafaleMax", 40, 5, 1000);
b.pop();
// 0.6 : une section par contrôle, avec ses propres seuils de VL (<= 0 : seuils globaux de [sanctions]).
b.comment("0.6 (P2.6) inventaire : ChestStealer, InventoryMove, InvCleaner / AutoArmor. OBSERVE par défaut.",
"Les mods d'inventaire côté client (Mouse Tweaks, Inventory Profiles) font des rafales de shift-clics : à observer avant ENFORCE.").push("inventaire");
V06.put("inventaireReactionMinMs", b.comment("Réaction minimale (ms, ping retiré) entre l'ouverture d'un conteneur et la première prise.")
.defineInRange("inventaireReactionMinMs", 100, 0, 1000));
V06.put("inventaireIntervalleMaxTicks", b.comment("Intervalle moyen (ticks) entre deux prises d'objets différents au-delà duquel la session n'est pas suspecte.")
.defineInRange("inventaireIntervalleMaxTicks", 1.5, 0.0, 20.0));
V06.put("inventairePrisesMin", b.comment("Prises d'objets différents dans la session avant de juger.")
.defineInRange("inventairePrisesMin", 4, 2, 54));
V06.put("inventairePingMaxMs", b.comment("Ping (ms) au plus retiré de la réaction (le ping est falsifiable).")
.defineInRange("inventairePingMaxMs", 300, 0, 2000));
V06.put("inventaireGraceRotationTicks", b.comment("Grâce (ticks) après l'ouverture avant de compter les rotations (plus ping / 50).")
.defineInRange("inventaireGraceRotationTicks", 10, 0, 200));
V06.put("inventaireRotationsMin", b.comment("Rotations avec un conteneur ouvert (une ouverture) avant que chacune compte.")
.defineInRange("inventaireRotationsMin", 3, 1, 100));
V06.put("inventaireSeuilSetback", b.defineInRange("inventaireSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("inventaireSeuilExpulsion", b.defineInRange("inventaireSeuilExpulsion", 30.0, 0.0, 1000.0));
b.pop();
b.comment("0.6 (P3.2) scaffold horizontal : pont posé sous les pieds hors du regard ou avec des rotations aller-retour (snap). OBSERVE par défaut.").push("scaffold");
V06.put("scaffoldAngleMaxDeg", b.comment("Écart (degrés) entre le regard et le point cliqué au-delà duquel la pose est hors regard.")
.defineInRange("scaffoldAngleMaxDeg", 50.0, 10.0, 180.0));
V06.put("scaffoldSnapDeg", b.comment("Rotation (degrés) aller puis retour autour d'une pose au-delà de laquelle c'est un snap.")
.defineInRange("scaffoldSnapDeg", 70.0, 20.0, 180.0));
V06.put("scaffoldSerieMin", b.comment("Poses anormales parmi les 10 dernières poses de pont (30 s) avant de compter.")
.defineInRange("scaffoldSerieMin", 4, 1, 10));
V06.put("scaffoldSeuilSetback", b.defineInRange("scaffoldSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("scaffoldSeuilExpulsion", b.defineInRange("scaffoldSeuilExpulsion", 30.0, 0.0, 1000.0));
b.pop();
b.comment("0.6 (P3.4) blink : trou de paquets de mouvement pendant que d'autres paquets arrivent. OBSERVE par défaut.",
"Un blink qui retient tous les paquets ressemble à un vrai lag : il n'est pas détecté ici.").push("blink");
V06.put("blinkTrouMinTicks", b.comment("Trou (ticks) sans mouvement à partir duquel il est mesuré (vanilla : un paquet au moins toutes les 20).")
.defineInRange("blinkTrouMinTicks", 30, 22, 600));
V06.put("blinkAutresMin", b.comment("Autres paquets (ticks distincts) reçus pendant le trou avant de le juger.")
.defineInRange("blinkAutresMin", 2, 1, 100));
V06.put("blinkSeuilSetback", b.defineInRange("blinkSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("blinkSeuilExpulsion", b.defineInRange("blinkSeuilExpulsion", 30.0, 0.0, 1000.0));
b.pop();
b.comment("0.6 (P3.5) phase : positions refusées par vanilla dont la boîte est dans un bloc solide (tentatives de NoClip / VClip).",
"Vanilla refuse déjà le passage ; ce contrôle compte les tentatives. OBSERVE par défaut.").push("phase");
V06.put("phaseSerieMin", b.comment("Refus dans un bloc en 10 s avant que chacun compte.")
.defineInRange("phaseSerieMin", 5, 1, 32));
V06.put("phaseSeuilSetback", b.defineInRange("phaseSeuilSetback", 10.0, 0.0, 1000.0));
V06.put("phaseSeuilExpulsion", b.defineInRange("phaseSeuilExpulsion", 30.0, 0.0, 1000.0));
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");
XRAY_PCT = b.comment("Part (%) de minerais rares (diamant, débris antiques) parmi les blocs cassés en profondeur au-delà de laquelle on alerte.")
.defineInRange("xrayAlerteDiamantsParCent", 5.0, 0.5, 100.0);
XRAY_CACHES = b.comment("Part des minerais rares cassés sans face à l'air, à un fluide ou à un bloc non plein.")
.defineInRange("xrayAlerteNonExposesPart", 0.8, 0.0, 1.0);
XRAY_Y = b.comment("Seuls les blocs cassés à cette hauteur ou plus bas comptent.")
.defineInRange("xrayAlerteYMax", 16, -64, 320);
XRAY_RARES = b.comment("Minerais rares dans la fenêtre (400 derniers blocs) avant toute alerte.")
.defineInRange("xrayRaresMin", 12, 1, 400);
b.pop();
b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic");
DIAG_ACTIONS = b.comment("Journaliser les ABORT de casse de bloc sans START correspondant (message vanilla « Mismatch in destroy block pos »),",
"au plus une ligne toutes les 10 s par joueur.")
.define("actionsBlocIncoherentes", true);
b.pop();
b.comment("0.5 : grâces à la connexion (reconnexion en l'air, expulsion récente).").push("graces");
GRACE_CONNEXION = b.comment("Ticks sans contrôle de mouvement ni timer après la connexion (la téléportation de connexion en donne déjà graceTeleportTicks).")
.defineInRange("graceConnexionTicks", 100, 0, 1200);
GRACE_APRES_EXPULSION = b.comment("Idem si le joueur a été expulsé il y a moins de 10 minutes.")
.defineInRange("graceApresExpulsionTicks", 200, 0, 2400);
SETBACK_SOL = b.comment("Sans position de retour valide (reconnexion en l'air), le SETBACK ramène au sol juste sous le joueur.",
"Jamais de déplacement horizontal. false = ancien comportement (setback impossible, seulement journalisé).")
.define("setbackSolSiPasDePosition", true);
b.pop();
b.push("exemptions");
@@ -210,6 +477,9 @@ public final class GardeSpec {
AC_EMPILEMENT_MAX = b.comment("Minecarts au plus qui se chevauchent : au-delà, leur poussée mutuelle est coupée et les",
"excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.")
.defineInRange("minecartsSuperposesMax", 4, 0, 64);
AC_EMPILEMENT_MOUVEMENT = b.comment("C18 : ne casser que les minecarts empilés en mouvement ou sans contenu ; un stockage",
"immobile de minecarts à coffre / à trémie n'est plus cassé (poussée coupée, journal seulement). Défaut false.")
.define("empilementSeulementEnMouvement", false);
AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).")
.define("alertesOps", true);
b.pop();
@@ -246,6 +516,9 @@ public final class GardeSpec {
c.seuilSetback = Math.max(SEUIL_SETBACK.get(), c.seuilAlerte);
c.seuilExpulsion = Math.max(SEUIL_EXPULSION.get(), c.seuilSetback);
c.sanctionMax = SANCTION_MAX.get();
c.journalToujoursSanctions = JOURNAL_TOUJOURS.get();
c.journalLignesParSeconde = JOURNAL_LIMITE.get();
c.diagnosticActionsBloc = DIAG_ACTIONS.get();
c.angleMaxDegres = ANGLE_MAX.get();
c.ciblesMax = CIBLES_MAX.get();
c.fenetreCiblesMs = FENETRE_CIBLES_MS.get();
@@ -265,8 +538,38 @@ public final class GardeSpec {
c.seriePingMaxMs = SERIE_PING_MAX.get();
c.seriePingMargeMs = SERIE_PING_MARGE.get();
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
c.timerDetteMax = TIMER_DETTE_MAX.get();
c.suspicionActive = SUSP_ACTIVE.get();
c.suspicionSeuilSurveiller = SUSP_SURVEILLER.get();
c.suspicionSeuilSuspect = Math.max(SUSP_SUSPECT.get(), c.suspicionSeuilSurveiller);
c.suspicionSeuilFort = Math.max(SUSP_FORT.get(), c.suspicionSeuilSuspect);
c.suspicionDemiVieMinutes = SUSP_DEMI_VIE.get();
c.suspicionPlafondFiable = SUSP_PLAFOND_FIABLE.get();
c.suspicionPlafondMoyen = SUSP_PLAFOND_MOYEN.get();
c.suspicionPlafondFaible = SUSP_PLAFOND_FAIBLE.get();
c.suspicionDiversiteControles = SUSP_DIVERSITE.get();
c.suspicionDiversiteFenetreMinutes = SUSP_DIVERSITE_FENETRE.get();
c.suspicionHistoriqueJours = SUSP_JOURS.get();
c.volFlottementTicks = VOL_FLOTTEMENT.get();
c.elytresMonteeTicks = ELY_MONTEE.get();
c.elytresStationnaireTicks = ELY_STATIONNAIRE.get();
c.elytresDeploiementsMax = ELY_DEPLOIEMENTS.get();
c.velociteFenetreTicks = VEL_FENETRE.get();
c.velociteRapportMin = VEL_RAPPORT.get();
c.velociteSerieMin = VEL_SERIE.get();
c.velociteForceMin = VEL_FORCE.get();
c.velocitePoints = VEL_POINTS.get();
c.autoTotemSeuilSetback = TOTEM_SEUIL_SB.get();
c.autoTotemSeuilExpulsion = TOTEM_SEUIL_EXP.get();
c.velociteSeuilSetback = VEL_SEUIL_SB.get();
c.velociteSeuilExpulsion = VEL_SEUIL_EXP.get();
c.totemDelaiMinMs = TOTEM_DELAI.get();
c.totemPingMaxMs = TOTEM_PING.get();
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
c.vitesseMoyenne = VITESSE_MOYENNE.get();
c.elytresExemptionStricte = ELYTRES_STRICTE.get();
c.elytresAirMinTicks = ELYTRES_AIR_MIN.get();
c.combatMesureEnVehicule = COMBAT_VEHICULE.get();
c.serieManqueBlocs = SERIE_MANQUE.get();
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
c.serieCoups = SERIE_COUPS.get();
@@ -274,6 +577,56 @@ public final class GardeSpec {
c.serieFenetreMs = SERIE_FENETRE_MS.get();
c.seriePoints = SERIE_POINTS.get();
c.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceConnexionTicks = GRACE_CONNEXION.get();
c.stepHauteurMax = STEP_HAUTEUR.get();
c.stepMargeBlocs = STEP_MARGE.get();
c.criticalsMicroSautMax = CRIT_MICRO.get();
c.criticalsSerieMin = CRIT_SERIE.get();
c.antiFaimTicks = ANTI_FAIM_TICKS.get();
c.noSlowFacteur = NO_SLOW_FACTEUR.get();
c.noSlowGraceTicks = NO_SLOW_GRACE.get();
c.noSlowTicks = NO_SLOW_TICKS.get();
c.jesusTicks = JESUS_TICKS.get();
c.omnisprintAngleDegres = OMNI_ANGLE.get();
c.omnisprintTicks = OMNI_TICKS.get();
c.xrayAlerteDiamantsParCent = XRAY_PCT.get();
c.xrayAlerteNonExposesPart = XRAY_CACHES.get();
c.xrayAlerteYMax = XRAY_Y.get();
c.xrayRaresMin = XRAY_RARES.get();
c.fastBreakFacteur = FAST_BREAK_FACTEUR.get();
c.fastBreakTicksMin = FAST_BREAK_TICKS_MIN.get();
c.fastBreakSerieMin = FAST_BREAK_SERIE.get();
c.fastPlaceSerie = FAST_PLACE_SERIE.get();
c.fastPlaceRegularite = FAST_PLACE_REGULARITE.get();
c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get();
c.interactionBlocMarge = INTER_MARGE.get();
c.interactionBlocSerieMin = INTER_SERIE.get();
c.interactionBlocGraceChangementMs = INTER_GRACE.get();
c.autoTotemEchantillons = TOTEM_ECHANT.get();
c.autoTotemEcartTypeMinMs = TOTEM_ECART.get();
c.autoTotemRegulierMaxMs = TOTEM_REG_MAX.get();
c.nukerBlocsParTickMax = NUKER_MAX.get();
c.nukerSerieMin = NUKER_SERIE.get();
c.nukerIgnorerCassesSansPaquet = NUKER_SANS_PAQUET.get();
c.cristalDelaiMinTicks = CRISTAL_DELAI.get();
c.cristalSerieMin = CRISTAL_SERIE.get();
c.towerIntervalleMinTicks = TOWER_INTERVALLE.get();
c.towerSerie = TOWER_SERIE.get();
c.completionParSecondeMax = COMPLETION_PAR_S.get();
c.completionRafaleMax = COMPLETION_RAFALE.get();
// 0.6 : champs du même nom dans GardeConfig (vérifié par Reglages06Test).
for (java.util.Map.Entry<String, ModConfigSpec.ConfigValue<?>> e : V06.entrySet()) {
try {
java.lang.reflect.Field f = GardeConfig.class.getField(e.getKey());
Object val = e.getValue().get();
if (f.getType() == int.class) f.setInt(c, ((Number) val).intValue());
else f.setDouble(c, ((Number) val).doubleValue());
} catch (ReflectiveOperationException ex) {
throw new IllegalStateException("reglage 0.6 sans champ : " + e.getKey(), ex);
}
}
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get();
c.tpsLag = TPS_LAG.get();
@@ -341,6 +694,7 @@ public final class GardeSpec {
r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault();
r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault();
r.empilementSeulementEnMouvement = l ? AC_EMPILEMENT_MOUVEMENT.get() : AC_EMPILEMENT_MOUVEMENT.getDefault();
return r;
}
+9 -1
Voir le fichier
@@ -15,7 +15,15 @@ public class GastinelGarde {
public static final String MOD_ID = "gastinelgarde";
public static final Logger LOGGER = LoggerFactory.getLogger(GastinelGarde.class);
/** 0.5 (P1.4) : version du mod (neoforge.mods.toml, rempli depuis gradle.properties au build). */
private static String version = "?";
public static String version() {
return version;
}
public GastinelGarde(IEventBus modEventBus, ModContainer modContainer) {
version = modContainer.getModInfo().getVersion().toString();
// Config rechargeable : config/gastinelgarde-server.toml (décision D8), plus /garde reload.
modContainer.registerConfig(ModConfig.Type.COMMON, GardeSpec.SPEC, "gastinelgarde-server.toml");
modEventBus.addListener(ModConfigEvent.Loading.class, GardeSpec::onConfig);
@@ -25,6 +33,6 @@ public class GastinelGarde {
NeoForge.EVENT_BUS.register(GardeCommands.class);
NeoForge.EVENT_BUS.register(GardeAntiCrash.class); // anti-crash entités (16/10), toujours actif
LOGGER.info("[GastinelGarde] Anti-triche chargé (tous les contrôles démarrent en observe).");
LOGGER.info("[GastinelGarde] Anti-triche {} chargé (tous les contrôles démarrent en observe).", version);
}
}
+53
Voir le fichier
@@ -0,0 +1,53 @@
package com.gastinelgarde.core;
/**
* 0.5 (P1.13) : diagnostic du message vanilla « Mismatch in destroy block pos: (0,0,0) … ». D'après
* ServerPlayerGameMode.handleBlockBreakAction (sources NeoForge 21.1.234) : {@code destroyPos} vaut (0,0,0) au départ
* et n'est mis à jour qu'à un START_DESTROY_BLOCK accepté (événement LeftClickBlock non annulé, à portée, interaction
* permise, pas créatif, pas de casse instantanée). Un ABORT sur une autre position donne le message. Causes
* possibles : START annulé par un mod (protection de zone), START refusé (trop loin), casse instantanée, ou client
* qui envoie ABORT sans START (FastBreak, Nuker, mod client) [À VÉRIFIER avec ces lignes de journal].
*
* Aucun contrôle, aucune sanction : une ligne de journal par incohérence, au plus une toutes les 10 s par joueur.
*/
public final class ActionsBloc {
public static final long DELAI_JOURNAL_MS = 10_000;
private boolean startVu;
private long startX, startY, startZ;
private boolean startAnnule;
private long dernierJournalMs = Long.MIN_VALUE;
private int incoherences;
/** START_DESTROY_BLOCK reçu ; {@code annule} : l'événement a été annulé par un mod. */
public void start(long x, long y, long z, boolean annule) {
startVu = true;
startX = x;
startY = y;
startZ = z;
startAnnule = annule;
}
/**
* ABORT_DESTROY_BLOCK reçu : texte de diagnostic s'il ne correspond pas au dernier START accepté (null sinon, ou si
* une ligne a déjà été écrite il y a moins de {@link #DELAI_JOURNAL_MS}).
*/
public String abort(long x, long y, long z, long nowMs) {
boolean memePos = startVu && startX == x && startY == y && startZ == z;
if (memePos && !startAnnule) return null;
incoherences++;
if (dernierJournalMs != Long.MIN_VALUE && nowMs - dernierJournalMs < DELAI_JOURNAL_MS && nowMs >= dernierJournalMs) {
return null;
}
dernierJournalMs = nowMs;
String start = !startVu ? "aucun START vu"
: String.format("dernier START (%d,%d,%d)%s", startX, startY, startZ, startAnnule ? " annule par un mod" : "");
return String.format("ABORT (%d,%d,%d) sans START correspondant : %s, %d incoherence(s) depuis la connexion",
x, y, z, start, incoherences);
}
public int incoherences() {
return incoherences;
}
}
+19
Voir le fichier
@@ -48,6 +48,14 @@ public final class AntiCrashEntites {
public double vitesseMaxMinecart = 3.0;
/** Minecarts au plus qui se chevauchent ; au-delà, la poussée mutuelle est coupée et les excédentaires cassés. */
public int empilementMax = 4;
/**
* C18 (16/10) : ne casser que les minecarts en mouvement ou sans contenu (minecart simple). Les minecarts à
* coffre / à trémie immobiles d'un stockage honnête ne sont plus cassés (poussée coupée, journal seulement).
* Désactivé par défaut : décision de Théo.
*/
public boolean empilementSeulementEnMouvement = false;
/** C18 : vitesse (blocs/tick) au-delà de laquelle un minecart empilé est « en mouvement ». */
public double empilementVitesseMin = 0.05;
}
/** Bordure du monde (rectangle horizontal). */
@@ -136,6 +144,17 @@ public final class AntiCrashEntites {
return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax;
}
/**
* C18 : ce minecart empilé doit-il être cassé ?
* @param vitesse norme de sa vitesse (blocs/tick)
* @param contenant minecart à coffre, à trémie… (casser répand le contenu)
*/
public static boolean empilementACasser(int minecartsQuiSeChevauchent, Reglages r, double vitesse, boolean contenant) {
if (!empilementExcessif(minecartsQuiSeChevauchent, r)) return false;
if (!r.empilementSeulementEnMouvement) return true;
return !contenant || !(vitesse <= r.empilementVitesseMin);
}
/** Position dans la bordure + marge, et dans les limites absolues du jeu. */
public static boolean dansLimites(Bordure b, double marge, double x, double y, double z) {
if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) {
+35
Voir le fichier
@@ -0,0 +1,35 @@
package com.gastinelgarde.core;
/**
* 0.5 (P1.8) : anti-faim (AntiHunger). Vanilla 1.21.1 (ServerPlayer.checkMovementStatistics, vérifié dans les
* sources NeoForge 21.1.234) ne fait perdre de la faim à la course (0,1 par bloc) que si {@code onGround()}, drapeau
* recopié du paquet du CLIENT. Le cheat déclare « pas au sol » en courant sur un sol plat : aucune faim perdue.
*
* Signal : {@link GardeConfig#antiFaimTicks} paquets consécutifs où le serveur voit le joueur courir (sprint) au sol,
* sans aucun déplacement vertical, avec un vrai déplacement horizontal, alors que le client se dit en l'air. Un
* joueur honnête qui court sur du plat se déclare au sol à chaque paquet ; un saut a toujours dy ≠ 0. Plusieurs
* ticks entre deux paquets ou un milieu spécial coupent la série. OBSERVE par défaut.
*/
public final class AntiFaim {
/** Déplacement horizontal minimal par tick pour compter (la marche lente ne coûte rien de toute façon). */
static final double DXZ_MIN = 0.1;
private int serie;
public double enregistrer(EtatMouvement m, GardeConfig cfg) {
boolean suspect = m.sprint() && !m.auSolClient() && m.auSolServeur() && Math.abs(m.dy()) < 1e-6
&& m.ticks() == 1 && m.dxz() >= DXZ_MIN && !m.milieuSpecial();
if (!suspect) {
serie = 0;
return 0;
}
if (++serie < Math.max(1, cfg.antiFaimTicks)) return 0;
serie = 0; // une infraction par série complète
return 2.0;
}
public void vider() {
serie = 0;
}
}
+39
Voir le fichier
@@ -0,0 +1,39 @@
package com.gastinelgarde.core;
/**
* 0.5 (P3.1) : AutoCrystal / CrystalAura. Le module pose un cristal de l'End et le frappe aussitôt, souvent dans le
* même tick serveur. Un joueur humain enchaîne « clic droit, clic gauche » en au moins un ou deux ticks ; la gigue
* réseau peut toutefois regrouper ses deux paquets. Signal : âge du cristal (ticks serveur depuis son apparition, vue à
* {@code EntityJoinLevelEvent}, jamais pour un cristal rechargé depuis le disque) au moment du coup. Âge inférieur à
* {@link GardeConfig#cristalDelaiMinTicks} = coup suspect ; points seulement en série
* ({@link GardeConfig#cristalSerieMin} sur les {@link #SERIE} derniers coups sur un cristal récent, 60 s). Cristaux
* d'âge inconnu (posés avant, rechargés, autre mod) : non mesurés. Risque de faux positif élevé selon le rapport de
* recherche (PvP cristal rapide) : OBSERVE par défaut, plafond « faible » du score.
*/
public final class AutoCristal {
public static final int SERIE = 10;
public static final long FENETRE_MS = 60_000;
/** Au-delà de cet âge (ticks), le coup n'est pas mesuré (cristal ancien : rien à dire). */
public static final int AGE_MAX_MESURE = 40;
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
private int dernierCompte;
/** @param ageTicks âge du cristal frappé, négatif si inconnu. @return points d'infraction */
public double frappe(long nowMs, int ageTicks, GardeConfig cfg) {
if (ageTicks < 0 || ageTicks > AGE_MAX_MESURE) return 0;
boolean suspect = ageTicks < Math.max(1, cfg.cristalDelaiMinTicks);
dernierCompte = serie.ajouter(nowMs, suspect);
if (!suspect || dernierCompte < Math.max(1, cfg.cristalSerieMin)) return 0;
return 2.0;
}
public int dernierCompte() {
return dernierCompte;
}
public void vider() {
serie.vider();
}
}
+56
Voir le fichier
@@ -0,0 +1,56 @@
package com.gastinelgarde.core;
/**
* Contrôle « auto-totem » (0.4.0). Le cheat remet un totem en main dès l'éclatement, sans délai de réaction. Le
* serveur voit l'éclatement (LivingUseTotemEvent) puis le contenu des mains à chaque paquet de mouvement : le délai
* entre les deux ne peut pas être inférieur à l'aller-retour réseau (le client apprend l'éclatement après ping/2, sa
* demande arrive après ping/2 de plus) plus la réaction humaine (~150 ms, arrondi au tick de 50 ms). Le ping est
* falsifiable (F07) : il n'entre que borné à {@link GardeConfig#totemPingMaxMs}, donc un joueur qui gonfle son ping
* ne gagne qu'une marge limitée. Un totem de réserve déjà en main à l'éclatement annule la mesure.
*/
public final class AutoTotem {
/** Mesure abandonnée si aucun totem n'est remis dans ce délai. */
public static final long EXPIRATION_MS = 10_000;
private boolean actif;
private long eclatMs;
/** 0.5 (P2.7) : dernier délai mesuré (ms), -1 si aucun depuis la dernière lecture. */
private long dernierDelai = -1;
/** 0.5 (P2.7) : délai mesuré au dernier appel de {@link #mains}, puis oublié ; -1 si aucun. */
public long prendreDelai() {
long d = dernierDelai;
dernierDelai = -1;
return d;
}
/** @param reserveEnMain un autre totem était déjà dans l'autre main : rien à mesurer */
public void eclatement(long nowMs, boolean reserveEnMain) {
actif = !reserveEnMain;
eclatMs = nowMs;
}
/**
* Contenu des mains à un paquet de mouvement.
*
* @return points d'infraction (0 si rien)
*/
public double mains(long nowMs, boolean totemEnMain, int pingMs, GardeConfig cfg) {
if (!actif) return 0;
if (nowMs - eclatMs > EXPIRATION_MS) {
actif = false;
return 0;
}
if (!totemEnMain || nowMs <= eclatMs) return 0;
actif = false;
long delai = nowMs - eclatMs;
dernierDelai = delai;
long minimum = cfg.totemDelaiMinMs + Math.min(Math.max(0, pingMs), cfg.totemPingMaxMs);
return delai < minimum ? 3.0 : 0;
}
public void vider() {
actif = false;
}
}
+66
Voir le fichier
@@ -0,0 +1,66 @@
package com.gastinelgarde.core;
/**
* 0.6 (P3.4) : Blink / FakeLag. Le client vanilla envoie un paquet de position au moins toutes les 20 ticks, même
* immobile ({@code positionReminder}, LocalPlayer). TCP garde l'ordre des paquets : pendant un vrai lag, <i>tous</i>
* les paquets attendent, puis arrivent ensemble dans l'ordre (mouvements et clics mêlés). Le Blink retient seulement
* les paquets de mouvement et laisse passer le reste (coups, clics, interactions) : le serveur reçoit alors d'autres
* paquets alors qu'aucun mouvement n'est arrivé depuis plus de 20 ticks.
*
* Signal : un trou d'au moins {@link GardeConfig#blinkTrouMinTicks} (30) ticks entre deux paquets de mouvement, pendant
* lequel d'autres paquets traités sur le thread serveur sont arrivés à au moins {@link GardeConfig#blinkAutresMin} (2)
* ticks distincts, chacun plus de 21 ticks après le dernier mouvement. Un gel du client (un seul tick de rattrapage :
* clic puis mouvement dans la même rafale) ne fait qu'un seul tick. Un Blink qui retient <b>tous</b> les paquets est
* indistinguable d'un vrai lag : seul le timer (solde de paquets) en voit une partie. OBSERVE par défaut.
*/
public final class Blink {
/** Au-delà, le rappel de position vanilla aurait dû arriver (20 ticks, plus un de gigue). */
public static final int RAPPEL_TICKS = 21;
private long dernierMouvTick = Long.MIN_VALUE;
private long dernierAutreTick = Long.MIN_VALUE;
private int autres;
private long dernierTrou;
private int dernierAutres;
/** Un autre paquet (coup, clic sur un bloc, clic de conteneur, complétion…) vient d'être traité. */
public void autrePaquet(long tick) {
if (dernierMouvTick == Long.MIN_VALUE || tick == dernierAutreTick) return;
if (tick - dernierMouvTick > RAPPEL_TICKS) {
autres++;
dernierAutreTick = tick;
}
}
/** Paquet de mouvement : renvoie les points du trou qui se termine. */
public double mouvement(long tick, GardeConfig cfg) {
double pts = 0;
if (dernierMouvTick != Long.MIN_VALUE) {
dernierTrou = tick - dernierMouvTick;
dernierAutres = autres;
if (dernierTrou >= Math.max(RAPPEL_TICKS + 1, cfg.blinkTrouMinTicks) && autres >= Math.max(1, cfg.blinkAutresMin)) {
pts = 2.0;
}
}
dernierMouvTick = tick;
dernierAutreTick = Long.MIN_VALUE;
autres = 0;
return pts;
}
/** Exemption (téléportation, véhicule, mort, gel du serveur…) : le prochain mouvement repart de zéro. */
public void vider() {
dernierMouvTick = Long.MIN_VALUE;
dernierAutreTick = Long.MIN_VALUE;
autres = 0;
}
public long dernierTrou() {
return dernierTrou;
}
public int dernierAutres() {
return dernierAutres;
}
}
+39
Voir le fichier
@@ -0,0 +1,39 @@
package com.gastinelgarde.core;
/**
* 0.5 (P3.7) : spam de demandes de complétion de commande (ServerboundCommandSuggestionPacket, touche Tab et frappe
* dans le chat après « / »). Vanilla 1.21.1 (ServerGamePacketListenerImpl.handleCustomCommandSuggestions, sources
* NeoForge 21.1.234) analyse la commande complète (jusqu'à 32 500 caractères) à chaque paquet, sans aucune limite de
* débit : un client forgé peut faire tirer le serveur. Le client vanilla en envoie une par frappe de touche.
*
* Seau à jetons : capacité {@link GardeConfig#completionRafaleMax} (40), rempli à
* {@link GardeConfig#completionParSecondeMax} (20) jetons par seconde. Un paquet sans jeton est en excès : 0,25 point
* chacun ; en ENFORCE il est ignoré (pas de réponse), quel que soit le palier.
*/
public final class Completion {
private double jetons = Double.NaN;
private long dernierMs;
private int excesTotal;
/** Une demande de complétion reçue. @return vrai si elle est en excès */
public boolean demande(long nowMs, GardeConfig cfg) {
double capacite = Math.max(1, cfg.completionRafaleMax);
if (Double.isNaN(jetons)) {
jetons = capacite;
} else if (nowMs > dernierMs) {
jetons = Math.min(capacite, jetons + (nowMs - dernierMs) * Math.max(1, cfg.completionParSecondeMax) / 1000.0);
}
dernierMs = Math.max(dernierMs, nowMs);
if (jetons >= 1) {
jetons -= 1;
return false;
}
excesTotal++;
return true;
}
public int excesTotal() {
return excesTotal;
}
}
+58 -1
Voir le fichier
@@ -17,7 +17,51 @@ public enum Controle {
VITESSE("vitesse"),
VOL("vol"),
VEHICULE_VITESSE("vehicule-vitesse"),
VEHICULE_VOL("vehicule-vol");
VEHICULE_VOL("vehicule-vol"),
/** 0.4.0 : plané en élytres (Elytra Hack) : montée sans perte de vitesse, plané immobile. */
ELYTRES("elytres"),
/** 0.4.0 : recul absent après un coup subi (Anti Knockback, Anti Push). */
VELOCITE("velocite"),
/** 0.4.0 : totem remis en main sans délai humain après l'éclatement (Auto Totem). */
AUTO_TOTEM("auto-totem"),
/** 0.5 (P1.9) : marche plus haute que la hauteur permise en un tick, au sol avant et après (Step / HighStep). */
STEP("step"),
/** 0.5 (P1.10) : coups critiques en série sans vrai saut ni vraie chute (Criticals, micro-sauts fictifs). */
CRITICALS("criticals"),
/** 0.5 (P1.8) : course au sol déclarée « en l'air » par le client pour ne pas perdre de faim (AntiHunger). */
ANTI_FAIM("anti-faim"),
/** 0.5 (P2.1) : vitesse de marche ou de course gardée pendant un usage d'objet (NoSlow). */
NO_SLOW("no-slow"),
/** 0.5 (P2.3) : blocs cassés en série avant la fin de leur temps de casse (FastBreak, la marge vanilla de 30 %). */
FAST_BREAK("fast-break"),
/** 0.5 (P2.4) : poses de blocs à chaque tick avec une régularité de machine (FastPlace). */
FAST_PLACE("fast-place"),
/** 0.5 (P2.5) : clic sur un bloc impossible pour le rayon vanilla (AirPlace, face cachée, portée, impact forgé). */
INTERACTION_BLOC("interaction-bloc"),
/** 0.5 (P2.7) : délais de remise du totem trop réguliers sur plusieurs éclatements (AutoTotem à délai fixe). */
AUTO_TOTEM_REGULIER("auto-totem-regulier"),
/** 0.5 (P2.11) : au sol déclaré sur un fluide, sans bloc ni entité dessous, sans chute (Jesus). */
JESUS("jesus"),
/** 0.5 (P2.14) : sprint en reculant ou de côté, soutenu au sol (Omnisprint). */
OMNISPRINT("omnisprint"),
/** 0.5 (P2.10) : part anormale de minerais rares non exposés (X-Ray) ; alerte seulement, jamais de sanction. */
XRAY("xray"),
/** 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"),
/** 0.5 (P3.2) : pilier monté plus vite que le saut vanilla, blocs posés sous les pieds (Scaffold Tower). */
TOWER("tower"),
/** 0.5 (P3.7) : demandes de complétion de commande au-delà d'un débit humain (spam de Tab, paquets forgés). */
COMPLETION("completion"),
/** 0.6 (P2.6) : ChestStealer, InventoryMove, InvCleaner / AutoArmor. */
INVENTAIRE("inventaire"),
/** 0.6 (P3.2) : pont posé sous les pieds hors du regard ou avec des rotations « snap » (Scaffold horizontal). */
SCAFFOLD("scaffold"),
/** 0.6 (P3.4) : trou de paquets de mouvement pendant que d'autres paquets arrivent (Blink / FakeLag). */
BLINK("blink"),
/** 0.6 (P3.5) : positions refusées par vanilla dans un bloc solide, en série (Phase / NoClip / VClip). */
PHASE("phase");
private final String id;
@@ -39,6 +83,19 @@ public enum Controle {
|| this == COUPS_HORS_BOITE;
}
/** Fiabilité du contrôle pour le score de suspicion : 0 = fiable, 1 = moyen, 2 = sujet aux faux positifs. */
public int fiabilite() {
return switch (this) {
case VOL, VITESSE, NO_FALL, PORTEE, HITBOX, REGULARITE, AUTO_TOTEM -> 0; // AUTO_TOTEM : 0.4.1
case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1;
// 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, TOWER, COMPLETION,
INVENTAIRE, SCAFFOLD, BLINK, PHASE -> 2; // 0.5 (P2) : idem
};
}
public static Controle parse(String texte) {
if (texte == null) return null;
for (Controle c : values()) {
+78
Voir le fichier
@@ -0,0 +1,78 @@
package com.gastinelgarde.core;
/**
* 0.5 (P1.10) : auto-criticals. Vanilla 1.21.1 (Player.attack, vérifié dans les sources NeoForge 21.1.234) donne un
* coup critique si {@code fallDistance > 0}, onGround faux (drapeau du CLIENT), pas d'échelle, pas d'eau, pas
* d'aveuglement, pas de véhicule, pas de sprint et barre d'attaque > 0,9. Le cheat envoie juste avant le coup un
* ou deux paquets « en l'air » avec un micro-saut (+0,0625 puis retour, ou onGround toujours faux) : le serveur
* compte une chute et accorde le critique sans vrai saut.
*
* Signal : au coup critique vanilla, depuis le dernier paquet où le client se disait au sol, le joueur n'est
* jamais monté de plus de {@link GardeConfig#criticalsMicroSautMax} ni descendu de plus de cette valeur. Un vrai
* saut monte d'environ 1,25 bloc ; une chute d'un rebord descend de plus de 0,1 dès le 2e tick. Un coup isolé ne
* compte pas : seulement une série ({@link GardeConfig#criticalsSerieMin} sur les {@link #SERIE} derniers critiques
* en {@link #FENETRE_MS}).
*
* Cas limite connu [À VÉRIFIER en jeu] : coup critique au tout premier tick de chute après avoir quitté un rebord
* (descente de 0,078 seulement) : vu comme suspect, d'où la série.
*/
public final class Criticals {
static final int SERIE = 10;
static final long FENETRE_MS = 60_000;
/** Au-delà, la référence au sol est abandonnée (longue chute, plané) : pas suspect. */
static final int PAQUETS_AIR_MAX = 40;
private boolean solConnu;
private double hauteur, haut, bas;
private int paquetsAir;
private final long[] instants = new long[SERIE];
private final boolean[] suspects = new boolean[SERIE];
private int n, prochain;
private int dernierCompte;
/** Chaque mouvement accepté (avant les exemptions : on suit seulement la hauteur). */
public void mouvement(EtatMouvement m) {
if (m.milieuSpecial()) {
solConnu = false; // eau, échelle : vanilla refuse le critique, et la hauteur n'a plus de sens
return;
}
if (m.auSolClient()) {
solConnu = true;
hauteur = haut = bas = 0;
paquetsAir = 0;
} else if (solConnu) {
hauteur += m.dy();
haut = Math.max(haut, hauteur);
bas = Math.min(bas, hauteur);
if (++paquetsAir > PAQUETS_AIR_MAX) solConnu = false;
}
}
/** Le critique en cours ne vient d'aucun vrai saut ni d'une vraie chute ? */
public boolean suspect(GardeConfig cfg) {
double s = cfg.criticalsMicroSautMax;
return solConnu && paquetsAir > 0 && haut < s && bas > -s;
}
/** Un coup critique vanilla : points si suspect et en série. */
public double coup(long nowMs, GardeConfig cfg) {
boolean s = suspect(cfg);
instants[prochain] = nowMs;
suspects[prochain] = s;
prochain = (prochain + 1) % SERIE;
n = Math.min(SERIE, n + 1);
int compte = 0;
for (int i = 0; i < n; i++) if (suspects[i] && nowMs - instants[i] <= FENETRE_MS) compte++;
dernierCompte = compte;
return s && compte >= Math.max(1, cfg.criticalsSerieMin) ? 2.0 : 0;
}
public int dernierCompte() {
return dernierCompte;
}
public double haut() { return haut; }
public double bas() { return bas; }
}
+38
Voir le fichier
@@ -0,0 +1,38 @@
package com.gastinelgarde.core;
/**
* 0.5 (P1.6) : déploiements d'élytres répétés (ElytraFly « packet »). Vanilla 1.21.1
* (ServerGamePacketListenerImpl.handlePlayerCommand, START_FALL_FLYING, et Player.tryToStartFallFlying, vérifiés
* dans les sources NeoForge 21.1.234) : un START_FALL_FLYING reçu pendant le plané ARRÊTE le plané
* ({@code stopFallFlying}), le suivant le relance. Le cheat qui en envoie un à chaque tick fait donc basculer le
* drapeau sans cesse, ce que le serveur voit (passage de « pas en plané » à « en plané » d'un paquet de mouvement au
* suivant). Un joueur qui redéploie ses élytres à la main le fait au plus quelques fois par seconde.
*
* Seuil : plus de {@link GardeConfig#elytresDeploiementsMax} déploiements sur la dernière seconde (20 ticks).
*/
public final class DeploiementsElytres {
static final long FENETRE_MS = 1000;
private static final int TAILLE = 64;
private final long[] instants = new long[TAILLE];
private int n, prochain;
private int dernierCompte;
/** Un déploiement vu (transition vers le plané) : points si trop de déploiements dans la fenêtre. */
public double deploiement(long nowMs, GardeConfig cfg) {
instants[prochain] = nowMs;
prochain = (prochain + 1) % TAILLE;
n = Math.min(TAILLE, n + 1);
int compte = 0;
for (int i = 0; i < n; i++) if (nowMs - instants[i] < FENETRE_MS && nowMs >= instants[i]) compte++;
dernierCompte = compte;
int max = cfg.elytresDeploiementsMax;
if (max <= 0 || compte <= max) return 0;
return 1.0 + Math.min(3.0, (compte - max) * 0.5);
}
public int dernierCompte() {
return dernierCompte;
}
}
+16 -4
Voir le fichier
@@ -15,11 +15,14 @@ public record EtatJoueur(
boolean enVehicule,
boolean pocheContraption,
boolean utiliseObjet,
boolean elytresDeploiementSuspect,
int ticksDepuisTeleport,
int ticksDepuisRecul,
int ticksDepuisGel,
double tps,
int pingMs) {
int pingMs,
boolean propulsionRecente,
boolean connexionRecente) {
public static final int JAMAIS = Integer.MAX_VALUE;
@@ -34,10 +37,12 @@ public record EtatJoueur(
public static final class Builder {
private boolean creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente;
private boolean enVehicule, pocheContraption, utiliseObjet;
private boolean enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect;
private int ticksDepuisTeleport = JAMAIS, ticksDepuisRecul = JAMAIS, ticksDepuisGel = JAMAIS;
private double tps = 20.0;
private int pingMs = 30;
private boolean propulsionRecente;
private boolean connexionRecente;
public Builder creatif(boolean v) { creatif = v; return this; }
public Builder spectateur(boolean v) { spectateur = v; return this; }
@@ -49,16 +54,23 @@ public record EtatJoueur(
public Builder enVehicule(boolean v) { enVehicule = v; return this; }
public Builder pocheContraption(boolean v) { pocheContraption = v; return this; }
public Builder utiliseObjet(boolean v) { utiliseObjet = v; return this; }
/** C7 : plané déclenché sans assez de ticks en l'air côté serveur (onGround probablement falsifié). */
public Builder elytresDeploiementSuspect(boolean v) { elytresDeploiementSuspect = v; return this; }
public Builder ticksDepuisTeleport(int v) { ticksDepuisTeleport = v; return this; }
public Builder ticksDepuisRecul(int v) { ticksDepuisRecul = v; return this; }
public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; }
public Builder tps(double v) { tps = v; return this; }
public Builder pingMs(int v) { pingMs = v; return this; }
/** 0.4.0 : fusée de feu d'artifice (ou autre poussée connue du serveur) récente : plané non contrôlé. */
public Builder propulsionRecente(boolean v) { propulsionRecente = v; return this; }
/** 0.5 (P1.2) : connexion récente (graceConnexionTicks, plus long après une expulsion récente). */
public Builder connexionRecente(boolean v) { connexionRecente = v; return this; }
public EtatJoueur build() {
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
enVehicule, pocheContraption, utiliseObjet, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs);
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs, propulsionRecente, connexionRecente);
}
}
}
+17 -3
Voir le fichier
@@ -9,7 +9,7 @@ import java.util.List;
*/
public final class Exemptions {
public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE }
public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE, MONDE }
/**
* @param exempt le contrôle ne doit pas s'appliquer
@@ -28,19 +28,24 @@ public final class Exemptions {
switch (famille) {
case COMBAT -> {
if (e.enVehicule()) raisons.add("vehicule");
// C8 (16/10) : option combatMesureEnVehicule (défaut false) : le passager est mesuré comme à pied.
if (e.enVehicule() && !cfg.combatMesureEnVehicule) raisons.add("vehicule");
if (e.pocheContraption()) raisons.add("contraption");
}
case MOUVEMENT -> {
if (e.peutVoler()) raisons.add("peut-voler");
if (e.riptide()) raisons.add("riptide");
if (e.elytres()) raisons.add("elytres");
// C7 (16/10) : option elytresExemptionStricte (défaut false) : un plané déclenché sans ticks en l'air
// côté serveur (onGround falsifié) n'exempte plus le mouvement.
if (e.elytres() && !(cfg.elytresExemptionStricte && e.elytresDeploiementSuspect())) raisons.add("elytres");
if (e.levitation()) raisons.add("levitation");
if (e.chuteLente()) raisons.add("chute-lente");
if (e.enVehicule()) raisons.add("vehicule");
if (e.pocheContraption()) raisons.add("contraption");
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
// 0.5 (P1.2) : reconnexion (souvent en l'air, sans position de retour) : grâce plus longue.
if (e.connexionRecente()) raisons.add("connexion");
}
case VEHICULE -> {
// F20 : le véhicule piloté. Pas d'exemption « véhicule » ici, évidemment.
@@ -48,9 +53,18 @@ public final class Exemptions {
if (e.pocheContraption()) raisons.add("contraption");
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
if (e.connexionRecente()) raisons.add("connexion");
}
case MONDE -> {
// 0.5 (P2) : casse et pose de blocs. Vaisseau Sable / contraption : coordonnées de sous-niveau, et
// gel du serveur : les paquets arrivent groupés, les temps mesurés ne veulent rien dire.
if (e.pocheContraption()) raisons.add("contraption");
if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur");
if (e.connexionRecente()) raisons.add("connexion");
}
case TIMER -> {
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
if (e.connexionRecente()) raisons.add("connexion"); // rafale de paquets du chargement
if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur");
}
}
+39
Voir le fichier
@@ -0,0 +1,39 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2) : faits supplémentaires d'un paquet de mouvement accepté, lus par l'adaptateur pour les contrôles P2
* (no-slow, jesus, omnisprint). Classe à champs publics plutôt qu'un record : chaque contrôle P2 y ajoute ce dont il
* a besoin sans casser les appels existants (tests, rejeu). Valeurs par défaut = « inconnu » : le contrôle concerné ne
* mesure pas.
*/
public final class FaitsMouvement {
/** Ticks depuis le début de l'usage d'objet en cours, vus par le serveur ({@code getTicksUsingItem}) ; -1 = inconnu. */
public int ticksUsage = -1;
/** P2.11 : fluide (eau, lave) au bloc des pieds ou juste dessous. */
public boolean surFluide;
/** P2.11 : entité solide (bateau, shulker…) ou vaisseau sous les pieds : on peut s'y tenir. */
public boolean entiteSolideSous;
/** P2.14 : déplacement horizontal signé depuis le paquet précédent ; NaN = inconnu. */
public double dx = Double.NaN, dz = Double.NaN;
/** P2.14 : regard horizontal (yaw Minecraft) ; NaN = inconnu. */
public float yaw = Float.NaN;
public FaitsMouvement ticksUsage(int v) {
ticksUsage = v;
return this;
}
public FaitsMouvement fluide(boolean surFluide, boolean entiteSolideSous) {
this.surFluide = surFluide;
this.entiteSolideSous = entiteSolideSous;
return this;
}
public FaitsMouvement direction(double dx, double dz, float yaw) {
this.dx = dx;
this.dz = dz;
this.yaw = yaw;
return this;
}
}
+71
Voir le fichier
@@ -0,0 +1,71 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.3) : FastBreak. Vanilla 1.21.1 (ServerPlayerGameMode.handleBlockBreakAction, vérifié dans les sources
* NeoForge 21.1.234) accepte un STOP_DESTROY_BLOCK dès que {@code getDestroyProgress × (ticks depuis START + 1) ≥ 0,7} :
* le serveur laisse 30 % d'avance au client. Les modules FastBreak s'arrêtent juste au-dessus de 0,7 ; un client
* honnête envoie STOP quand sa propre progression atteint 1, donc un rapport proche de 1 (au jitter réseau près).
*
* Mesure, à la casse effective (BlockEvent.BreakEvent) d'un bloc dont le START a été vu au même endroit :
* {@code rapport = progression par tick (serveur, outil et effets du moment) × (ticks écoulés + 1)}. Un rapport sous
* {@link GardeConfig#fastBreakFacteur} (0,8) est suspect. Les blocs qui demandent moins de
* {@link GardeConfig#fastBreakTicksMin} ticks ne sont pas mesurés (un tick de jitter y pèse trop) ; les blocs cassés
* d'un coup (progression ≥ 1) non plus. Un START retardé par le réseau raccourcit la mesure (faux positif possible) :
* points seulement en série ({@link GardeConfig#fastBreakSerieMin} casses suspectes sur les {@link #SERIE} dernières
* mesurées, en {@link #FENETRE_MS} ms). OBSERVE par défaut.
*/
public final class FastBreak {
public static final int SERIE = 10;
public static final long FENETRE_MS = 60_000;
private boolean debut;
private int x, y, z;
private long debutTick;
private double dernierRapport = Double.NaN;
private int dernierCompte;
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
/** START_DESTROY_BLOCK accepté (non annulé) sur ce bloc, au tick serveur donné. */
public void debut(long tick, int x, int y, int z) {
debut = true;
this.x = x;
this.y = y;
this.z = z;
debutTick = tick;
}
/**
* Le bloc vient d'être cassé par le joueur.
*
* @param progression progression de casse par tick vue par le serveur ({@code getDestroyProgress}) ; NaN = inconnue
* @return points d'infraction (0 si rien)
*/
public double casse(long nowMs, long tick, int x, int y, int z, double progression, GardeConfig cfg) {
boolean memeBloc = debut && this.x == x && this.y == y && this.z == z;
debut = false;
dernierRapport = Double.NaN;
if (!memeBloc || Double.isNaN(progression) || progression <= 0 || progression >= 1.0) return 0;
long ticks = tick - debutTick;
if (ticks < 0) return 0;
double attendus = Math.ceil(1.0 / progression);
if (attendus < cfg.fastBreakTicksMin) return 0;
dernierRapport = progression * (ticks + 1);
boolean suspect = dernierRapport < cfg.fastBreakFacteur;
dernierCompte = serie.ajouter(nowMs, suspect);
if (!suspect || dernierCompte < Math.max(1, cfg.fastBreakSerieMin)) return 0;
return 2.0;
}
public double dernierRapport() {
return dernierRapport;
}
public int dernierCompte() {
return dernierCompte;
}
public void vider() {
debut = false;
}
}
+66
Voir le fichier
@@ -0,0 +1,66 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.4) : FastPlace. Vanilla 1.21.1 (Minecraft.handleKeybinds, client) : clic droit maintenu = une pose toutes les
* 4 ticks ({@code rightClickDelay}), soit 5 par seconde, parfaitement régulière. Des clics rapides (butterfly,
* drag-click) passent outre ce délai et peuvent dépasser 20 clics par seconde : un simple plafond de poses par seconde
* ferait de fausses alertes. Le module FastPlace (délai 0) pose à chaque tick, avec une régularité qu'aucun clic humain
* n'a : c'est elle qui est mesurée.
*
* Signal : sur les {@link GardeConfig#fastPlaceSerie} derniers intervalles entre deux poses (en ticks serveur, poses du
* même tick regroupées), au moins {@link GardeConfig#fastPlaceRegularite} (90 %) valent exactement le même intervalle
* d, avec {@code d ≤} {@link GardeConfig#fastPlaceIntervalleMaxTicks} (1 par défaut : une pose à chaque tick). Une
* pause de plus d'une seconde remet la série à zéro. Le jitter réseau casse la régularité : il fait manquer un
* tricheur, jamais accuser un joueur honnête. OBSERVE par défaut.
*/
public final class FastPlace {
public static final int TAILLE_MAX = 64;
/** Pause (ticks) qui termine une série. */
public static final int PAUSE_TICKS = 20;
private final int[] intervalles = new int[TAILLE_MAX];
private int taille;
private int tete;
private long dernierTick = Long.MIN_VALUE;
private int dernierIntervalle;
/** Une pose de bloc par le joueur au tick serveur donné. @return points d'infraction */
public double pose(long tick, GardeConfig cfg) {
if (dernierTick != Long.MIN_VALUE && tick == dernierTick) return 0; // même tick : une seule pose comptée
long ecart = dernierTick == Long.MIN_VALUE ? Long.MAX_VALUE : tick - dernierTick;
dernierTick = tick;
if (ecart <= 0 || ecart > PAUSE_TICKS) {
vider();
dernierTick = tick;
return 0;
}
intervalles[tete] = (int) ecart;
tete = (tete + 1) % TAILLE_MAX;
if (taille < TAILLE_MAX) taille++;
int n = Math.max(2, Math.min(TAILLE_MAX, cfg.fastPlaceSerie));
if (taille < n) return 0;
// intervalle le plus fréquent parmi les n derniers
int[] compte = new int[PAUSE_TICKS + 1];
int mode = 0;
for (int k = 0; k < n; k++) {
int v = intervalles[((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX];
if (++compte[v] > compte[mode]) mode = v;
}
dernierIntervalle = mode;
if (mode > cfg.fastPlaceIntervalleMaxTicks || compte[mode] < cfg.fastPlaceRegularite * n) return 0;
vider(); // une infraction par série complète
dernierTick = tick;
return 2.0;
}
public int dernierIntervalle() {
return dernierIntervalle;
}
public void vider() {
taille = 0;
tete = 0;
dernierTick = Long.MIN_VALUE;
}
}
+195 -2
Voir le fichier
@@ -26,6 +26,59 @@ public final class GardeConfig {
/** C1 (16/10) : ticks de grâce du contrôle vol après la fin du plané en élytres (fin à l'atterrissage). */
public int graceFinElytresTicks = 50;
// --- 0.5 (P1.1, section [journal]) ---
/** Le verdict qui déclenche un SETBACK ou une EXPULSION est toujours écrit, malgré la limite de lignes. */
public boolean journalToujoursSanctions = true;
/** Lignes de journal au plus par seconde et par contrôle (hors verdicts de sanction ci-dessus). */
public int journalLignesParSeconde = 1;
// --- Score de suspicion (0.4.0, section [suspicion]) : information pour les humains, jamais de sanction ---
public boolean suspicionActive = true;
public double suspicionSeuilSurveiller = 25;
public double suspicionSeuilSuspect = 50;
public double suspicionSeuilFort = 75;
/** Demi-vie du score, en minutes de jeu (le suivi du joueur est libéré à la déconnexion). */
public double suspicionDemiVieMinutes = 10;
/** Plafonds de contribution par fiabilité du contrôle (fiable / moyen / sujet aux faux positifs). */
public double suspicionPlafondFiable = 50;
public double suspicionPlafondMoyen = 30;
public double suspicionPlafondFaible = 15;
/** Diversité : ce nombre de contrôles distincts au palier SETBACK ou plus dans la fenêtre = suspect fort. */
public int suspicionDiversiteControles = 3;
public double suspicionDiversiteFenetreMinutes = 10;
public int suspicionHistoriqueJours = 7;
// --- Vol : flottement (0.4.0), équivalent du « kicked for floating too long » vanilla (80 ticks) ---
/** Ticks consécutifs en l'air sans chute (dy par tick >= -0,03125, comme vanilla) avant infraction ; 0 = coupé. */
public int volFlottementTicks = 80;
// --- 0.4.0 : plané (elytres), vélocité (recul), auto-totem. OBSERVE par défaut, valeurs à valider en jeu ---
/** Ticks de montée sans perte de vitesse en plané avant infraction ; 0 = coupé. */
public int elytresMonteeTicks = 20;
/** Ticks de plané presque immobile et sans chute avant infraction ; 0 = coupé. */
public int elytresStationnaireTicks = 20;
/** 0.5 (P1.6) : déploiements d'élytres au plus par seconde (au-delà : ElytraFly « packet ») ; 0 = coupé. */
public int elytresDeploiementsMax = 5;
/** Ticks sur lesquels le recul est mesuré après un coup subi. */
public int velociteFenetreTicks = 6;
/** Recul absent si le déplacement dans le sens du recul est sous cette part du recul vanilla. */
public double velociteRapportMin = 0.15;
/** Reculs absents (sur les 6 derniers en 2 min) avant infraction. */
public int velociteSerieMin = 3;
/** Force de recul effective (après résistance) en dessous de laquelle on ne mesure pas. */
public double velociteForceMin = 0.15;
/** 0.4.1 : points par recul absent compte (en serie). 2 en dur en 0.4.0 : la decroissance (0,5/s) plafonnait le VL vers 5. */
public double velocitePoints = 4.0;
/** 0.4.2 : seuils propres a un controle ; valeur <= 0 = seuil global de [sanctions]. */
public double autoTotemSeuilSetback = 0;
public double autoTotemSeuilExpulsion = 9;
public double velociteSeuilSetback = 8;
public double velociteSeuilExpulsion = 16;
/** Réaction humaine minimale (ms) entre l'éclatement d'un totem et un totem remis en main, hors ping. */
public int totemDelaiMinMs = 150;
/** Ping (ms) au plus ajouté à ce délai (le ping est falsifiable). */
public int totemPingMaxMs = 200;
// --- Killaura ---
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
public double angleMaxDegres = 60.0;
@@ -97,11 +150,151 @@ public final class GardeConfig {
public boolean volFenetreGlissante = false;
/** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */
public boolean vitesseMoyenne = false;
/** C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé. */
public int timerSoldeMax = 0;
// --- C7 / C8 (16/10, constats hauts) : DÉSACTIVÉS par défaut (à valider en OBSERVE) ---
/**
* C7 : élytres. Pas d'exemption de mouvement si le plané a été déclenché sans au moins
* {@link #elytresAirMinTicks} ticks en l'air (sol serveur), et portée / hitbox mesurées pendant le plané.
*/
public boolean elytresExemptionStricte = false;
/** C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres. */
public int elytresAirMinTicks = 2;
/** C8 : le combat d'un passager de véhicule (bateau, cheval, minecart…) est mesuré comme à pied. */
public boolean combatMesureEnVehicule = false;
/**
* C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé.
* 0.5 (P1.12) : 20 par défaut (avant 0). Un fichier de configuration existant garde sa valeur.
*/
public int timerSoldeMax = 20;
/** 0.5 (P1.12) : crédit (paquets en retard) au plus remboursable par une rafale de rattrapage après un lag. */
public int timerDetteMax = 40;
// --- 0.5 (P1) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu ---
/** Step : hauteur de marche au moins permise (vanilla : attribut step_height, 0,6) ; l'attribut réel du joueur et sa puissance de saut s'ajoutent (maximum). */
public double stepHauteurMax = 0.6;
/** Step : marge (blocs) au-dessus de la hauteur permise. */
public double stepMargeBlocs = 0.1;
/** Criticals : coup critique suspect si, depuis le dernier « au sol » du client, ni montée ni descente au-delà (blocs). */
public double criticalsMicroSautMax = 0.1;
/** Criticals : coups critiques suspects, parmi les 10 derniers en 60 s, à partir desquels un critique suspect compte. */
public int criticalsSerieMin = 3;
/** Anti-faim : paquets consécutifs de course au sol déclarée « en l'air » avant infraction (1 s à 20 paquets/s). */
public int antiFaimTicks = 20;
// --- 0.5 (P2) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu ---
/** NoSlow : vitesse au sol permise pendant un usage d'objet = ce facteur × course (0,30) × effets ; vanilla ~0,2. */
public double noSlowFacteur = 0.5;
/** NoSlow : ticks d'usage d'objet (serveur) avant de mesurer (élan de la course, latence du début d'usage). */
public int noSlowGraceTicks = 3;
/** NoSlow : paquets suspects consécutifs avant infraction. */
public int noSlowTicks = 10;
/** FastBreak : rapport progression × ticks sous lequel une casse est suspecte (vanilla accepte dès 0,7). */
public double fastBreakFacteur = 0.8;
/** FastBreak : blocs plus rapides que ce nombre de ticks non mesurés (un tick de jitter y pèse trop). */
public int fastBreakTicksMin = 6;
/** FastBreak : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter. */
public int fastBreakSerieMin = 4;
/** FastPlace : intervalles entre poses examinés (poses du même tick regroupées). */
public int fastPlaceSerie = 40;
/** FastPlace : part de ces intervalles qui doivent valoir exactement le même nombre de ticks. */
public double fastPlaceRegularite = 0.9;
/** FastPlace : cet intervalle commun (ticks) au plus ; vanilla au clic maintenu : 4. */
public int fastPlaceIntervalleMaxTicks = 1;
/** Interaction de bloc : marge (blocs) de portée et de face, en plus du déplacement du dernier tick. */
public double interactionBlocMarge = 0.5;
/** Interaction de bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter. */
public int interactionBlocSerieMin = 3;
/** 0.6.1 (revue M3) : « bloc-vide » non compté si ce bloc a changé (casse, pose, clic de pose) depuis ce délai (ms). */
public int interactionBlocGraceChangementMs = 500;
/** Auto-totem régulier : délais (éclatement → totem en main) examinés. */
public int autoTotemEchantillons = 5;
/** Auto-totem régulier : écart type (ms) sous lequel ces délais sont ceux d'une machine. */
public int autoTotemEcartTypeMinMs = 30;
/** Auto-totem régulier : tous les délais examinés sous cette valeur (ms). */
public int autoTotemRegulierMaxMs = 300;
/** Jesus : paquets consécutifs « au sol » sur un fluide sans appui avant infraction. */
public int jesusTicks = 10;
/** Omnisprint : angle (degrés) entre déplacement et regard au-delà duquel un sprint est impossible en vanilla. */
public double omnisprintAngleDegres = 100;
/** Omnisprint : paquets consécutifs avant infraction. */
public int omnisprintTicks = 10;
/** X-Ray : part (%) de minerais rares parmi les blocs cassés en profondeur au-delà de laquelle on alerte. */
public double xrayAlerteDiamantsParCent = 5;
/** X-Ray : part des minerais rares cassés sans face à l'air ni à un fluide. */
public double xrayAlerteNonExposesPart = 0.8;
/** X-Ray : seuls les blocs cassés à cette hauteur ou plus bas comptent. */
public int xrayAlerteYMax = 16;
/** X-Ray : minerais rares dans la fenêtre avant toute alerte (un filon chanceux ne suffit pas). */
public int xrayRaresMin = 12;
// --- 0.5 (P3) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu ---
/** Nuker : blocs cassés dans un même tick serveur au-delà desquels le tick est suspect (vanilla : 1, gigue comprise : 3). */
public int nukerBlocsParTickMax = 3;
/** Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter. */
public int nukerSerieMin = 3;
/**
* 0.6.1 (revue M2) : vrai = le nuker ne compte que les casses visées par un paquet de casse du joueur dans le même
* tick ; les blocs cassés par un mod d'abattage / de minage de filon au nom du joueur sont ignorés. Faux par défaut.
*/
public boolean nukerIgnorerCassesSansPaquet = false;
/** Auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect (2 : même tick ou suivant). */
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;
/** Complétion : demandes par seconde soutenues permises (le client vanilla en envoie une par frappe). */
public int completionParSecondeMax = 20;
/** Complétion : rafale permise (capacité du seau). */
public int completionRafaleMax = 40;
// --- 0.6 : inventaire, scaffold, blink, phase. OBSERVE par défaut, seuils de VL propres (<= 0 = seuil global) ---
/** Inventaire : réaction minimale (ms, ping retiré) entre l'ouverture d'un conteneur et la première prise. */
public int inventaireReactionMinMs = 100;
/** Inventaire : intervalle moyen (ticks) entre deux prises au-delà duquel la session n'est pas suspecte. */
public double inventaireIntervalleMaxTicks = 1.5;
/** Inventaire : prises d'objets différents dans la session avant de juger. */
public int inventairePrisesMin = 4;
/** Inventaire : ping (ms) au plus retiré de la réaction (le ping est falsifiable). */
public int inventairePingMaxMs = 300;
/** Inventaire : grâce (ticks) après l'ouverture avant de compter les rotations, plus ping / 50. */
public int inventaireGraceRotationTicks = 10;
/** Inventaire : rotations avec un conteneur ouvert (une ouverture) avant que chacune compte. */
public int inventaireRotationsMin = 3;
public double inventaireSeuilSetback = 10;
public double inventaireSeuilExpulsion = 30;
/** Scaffold : écart (degrés) entre le regard et le point cliqué au-delà duquel la pose est hors regard. */
public double scaffoldAngleMaxDeg = 50;
/** Scaffold : rotation (degrés) aller puis retour autour d'une pose, au-delà de laquelle c'est un « snap ». */
public double scaffoldSnapDeg = 70;
/** Scaffold : poses anormales parmi les 10 dernières poses de pont (30 s) avant de compter. */
public int scaffoldSerieMin = 4;
public double scaffoldSeuilSetback = 10;
public double scaffoldSeuilExpulsion = 30;
/** Blink : trou (ticks) sans paquet de mouvement au-delà duquel il est mesuré (vanilla : un paquet au moins toutes les 20). */
public int blinkTrouMinTicks = 30;
/** Blink : autres paquets (ticks distincts) reçus pendant le trou avant de le juger. */
public int blinkAutresMin = 2;
public double blinkSeuilSetback = 10;
public double blinkSeuilExpulsion = 30;
/** Phase : positions refusées dans un bloc solide en 10 s avant que chacune compte. */
public int phaseSerieMin = 5;
public double phaseSeuilSetback = 10;
public double phaseSeuilExpulsion = 30;
// --- 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 »). */
public boolean diagnosticActionsBloc = true;
// --- Exemptions ---
public int graceTeleportTicks = 40;
/** 0.5 (P1.2) : grâce de mouvement / timer après la connexion (ticks) ; plus longue après une expulsion récente. */
public int graceConnexionTicks = 100;
public int graceApresExpulsionTicks = 200;
/** 0.5 (P1.2) : sans position de retour valide, le SETBACK ramène au sol juste sous le joueur (jamais à côté). */
public boolean setbackSolSiPasDePosition = true;
public int graceReculTicks = 20;
public int graceGelTicks = 100;
public double tpsLag = 18.0;
+86
Voir le fichier
@@ -0,0 +1,86 @@
package com.gastinelgarde.core;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Incidents de suspicion par UUID sur N jours (par défaut 7). Un incident = un franchissement vers « suspect » ou
* « suspect fort ». Persistance : un fichier texte, une ligne par incident, en ajout seulement (une coupure ne
* peut pas le corrompre au-delà d'une ligne, aucune dépendance, lisible à la main). Les lignes trop vieilles ou
* illisibles sont ignorées au chargement, et le fichier est réécrit compact si quelque chose a été écarté.
* Format : {@code epochMs;uuid;niveau;score;controles}.
*/
public final class HistoriqueSuspicion {
public record Incident(long epochMs, Suspicion.Niveau niveau, int score, String controles) { }
private final Map<UUID, List<Incident>> incidents = new HashMap<>();
private Path fichier;
/** Charge le fichier (s'il existe), ignore ce qui a plus de {@code jours} jours, et mémorise le chemin. */
public synchronized void ouvrir(Path chemin, long nowEpochMs, int jours) throws IOException {
this.fichier = chemin;
incidents.clear();
if (!Files.exists(chemin)) return;
long limite = nowEpochMs - jours * 86_400_000L;
boolean ecarte = false;
for (String ligne : Files.readAllLines(chemin, StandardCharsets.UTF_8)) {
if (ligne.isBlank()) continue;
String[] t = ligne.split(";", 5);
try {
if (t.length < 4) throw new IllegalArgumentException();
long ts = Long.parseLong(t[0]);
if (ts < limite) {
ecarte = true;
continue;
}
incidents.computeIfAbsent(UUID.fromString(t[1]), k -> new ArrayList<>()).add(new Incident(ts,
Suspicion.Niveau.valueOf(t[2]), Integer.parseInt(t[3]), t.length > 4 ? t[4] : ""));
} catch (RuntimeException e) {
ecarte = true;
}
}
if (ecarte) reecrire();
}
public synchronized void enregistrer(UUID joueur, long epochMs, Suspicion.Niveau niveau, int score, String controles) {
String ctl = controles == null ? "" : controles.replace(';', ',').replace('\n', ' ');
List<Incident> l = incidents.computeIfAbsent(joueur, k -> new ArrayList<>());
Incident i = new Incident(epochMs, niveau, score, ctl);
l.add(i);
if (fichier == null) return;
try {
if (fichier.getParent() != null) Files.createDirectories(fichier.getParent());
Files.writeString(fichier, ligne(joueur, i), StandardCharsets.UTF_8,
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException e) {
// la mémoire reste juste ; le fichier sera réécrit compact au prochain chargement
}
}
/** Nombre d'incidents des {@code jours} derniers jours. */
public synchronized int incidents(UUID joueur, long nowEpochMs, int jours) {
long limite = nowEpochMs - jours * 86_400_000L;
int n = 0;
for (Incident i : incidents.getOrDefault(joueur, List.of())) if (i.epochMs() >= limite) n++;
return n;
}
private static String ligne(UUID id, Incident i) {
return i.epochMs() + ";" + id + ";" + i.niveau() + ";" + i.score() + ";" + i.controles() + System.lineSeparator();
}
private void reecrire() throws IOException {
StringBuilder sb = new StringBuilder();
incidents.forEach((id, l) -> l.forEach(i -> sb.append(ligne(id, i))));
Files.writeString(fichier, sb.toString(), StandardCharsets.UTF_8);
}
}
+143
Voir le fichier
@@ -0,0 +1,143 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.5) : interaction avec un bloc impossible pour le lancer de rayon du client vanilla (AirPlace, Scaffold
* simple, casse ou pose à travers un bloc, portée de bloc). Le client vanilla n'envoie un clic sur un bloc que si son
* rayon (depuis l'œil, longueur = attribut {@code block_interaction_range}, 4,5 en survie) touche la forme de contour
* du bloc, sur la face par laquelle il entre. Le serveur (handleUseItemOn, vérifié dans les sources NeoForge
* 21.1.234) n'exige que : œil à moins de portée + 1 de la boîte du bloc, impact à moins d'un bloc du centre.
*
* Anomalies (une seule rapportée, la première) :
* <ul>
* <li>{@code bloc-vide} : le bloc cliqué est de l'air (AirPlace : le rayon vanilla ne touche jamais l'air) ;</li>
* <li>{@code face-cachee} : l'œil est derrière le plan de la face cliquée (plus de marge) : le rayon n'a pas pu y
* entrer ;</li>
* <li>{@code hors-portee} : impact (ou boîte du bloc, sans impact) à plus de portée + marge de l'œil ;</li>
* <li>{@code impact-hors-face} : bloc plein, impact pas sur le plan de la face cliquée (vecteur forgé).</li>
* </ul>
* La marge ({@link GardeConfig#interactionBlocMarge} 0,5) s'ajoute au déplacement du dernier tick : le rayon du client
* part de l'œil interpolé entre deux ticks. Au-delà de portée + 1, vanilla refuse déjà : si l'adaptateur voit plus
* loin, un mod a transformé les coordonnées (vaisseau Sable) et rien n'est mesuré.
*/
public final class InteractionBloc {
public static final int SERIE = 10;
public static final long FENETRE_MS = 60_000;
/** Tolérance (blocs) de l'impact sur le plan d'une face de bloc plein (flottants du paquet). */
public static final double TOLERANCE_PLAN = 0.01;
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
private int dernierCompte;
/**
* @param oeil œil du joueur (x, y, z)
* @param boite boîte de contour du bloc en coordonnées absolues (minX, minY, minZ, maxX, maxY, maxZ) ; pour un bloc
* sans contour, le cube unité
* @param face face cliquée, ordre de {@code Direction.get3DDataValue} : 0 bas, 1 haut, 2 nord (−z), 3 sud (+z),
* 4 ouest (−x), 5 est (+x) ; -1 = inconnue
* @param impact point d'impact envoyé par le client, null s'il n'y en a pas (début de casse)
* @param air le bloc cliqué est de l'air
* @param plein le bloc a une forme de cube plein
* @param portee portée d'interaction de bloc du joueur (attribut)
* @param marge marge (blocs), déplacement du dernier tick compris
* @return la première anomalie, null si aucune ou si les coordonnées ne sont pas mesurables
*/
public static String anomalie(double[] oeil, double[] boite, int face, double[] impact, boolean air, boolean plein,
double portee, double marge) {
double dBoite = Math.sqrt(distanceCarreeBoite(oeil, boite));
if (dBoite > portee + 1.0 + 1e-3) return null; // vanilla refuse ou un mod a transformé les coordonnées
if (air) return "bloc-vide";
if (face >= 0 && face <= 5) {
double[] plan = {boite[1], boite[4], boite[2], boite[5], boite[0], boite[3]};
int axe = face <= 1 ? 1 : face <= 3 ? 2 : 0;
boolean positive = face == 1 || face == 3 || face == 5;
double ecart = positive ? oeil[axe] - plan[face] : plan[face] - oeil[axe];
if (ecart < -marge) return "face-cachee";
if (impact != null && plein) {
boolean horsPlan = Math.abs(impact[axe] - plan[face]) > TOLERANCE_PLAN;
boolean horsBoite = false;
for (int a = 0; a < 3; a++) {
if (a == axe) continue;
if (impact[a] < boite[a] - TOLERANCE_PLAN || impact[a] > boite[a + 3] + TOLERANCE_PLAN) horsBoite = true;
}
if (horsPlan || horsBoite) return "impact-hors-face";
}
}
double d = impact != null ? Math.sqrt(carre(impact[0] - oeil[0]) + carre(impact[1] - oeil[1]) + carre(impact[2] - oeil[2]))
: dBoite;
if (d > portee + marge) return "hors-portee";
return null;
}
/** Une interaction mesurée ; {@code anomalie} null = normale. @return points d'infraction */
public double enregistrer(long nowMs, String anomalie, GardeConfig cfg) {
dernierCompte = serie.ajouter(nowMs, anomalie != null);
if (anomalie == null || dernierCompte < Math.max(1, cfg.interactionBlocSerieMin)) return 0;
return 2.0;
}
// Dernier événement évalué (seconde revue : dédoublonnage du seul clic vanilla MAIN puis OFF).
private long dernierMs = Long.MIN_VALUE;
private long derniereCle;
private int derniereMain = -1;
private int derniereFace;
private double[] dernierImpact;
private long dedoublonneMs = Long.MIN_VALUE;
private java.util.List<Verdict> derniersVerdicts = java.util.List.of();
private String derniereAnomalie;
/** Anomalie du dernier événement évalué (null si aucune). */
public String derniereAnomalie() {
return derniereAnomalie;
}
/**
* Vrai si cet événement est la main secondaire du clic vanilla qui vient d'être évalué en main principale : même
* instant, même bloc, même face, même point d'impact, et au plus une fois par instant. Tout le reste (deuxième
* événement identique de la même main, autre face, autre impact, troisième événement) est évalué normalement.
*
* @param main 0 = principale, 1 = secondaire
*/
public boolean secondeMainDuMemeClic(long nowMs, long cleBloc, int main, int face, double[] impact) {
return main == 1 && derniereMain == 0 && nowMs == dernierMs && cleBloc == derniereCle && face == derniereFace
&& java.util.Arrays.equals(impact, dernierImpact) && dedoublonneMs != nowMs;
}
/** La main secondaire dédoublonnée reprend la décision (verdicts) de la principale ; non recomptée. */
public java.util.List<Verdict> reprendre(long nowMs) {
dedoublonneMs = nowMs;
derniereMain = 1;
return derniersVerdicts;
}
/** Mémorise l'événement évalué et ses verdicts. */
public void memoriser(long nowMs, long cleBloc, int main, int face, double[] impact, String anomalie,
java.util.List<Verdict> verdicts) {
derniereAnomalie = anomalie;
dernierMs = nowMs;
derniereCle = cleBloc;
derniereMain = main;
derniereFace = face;
dernierImpact = impact == null ? null : impact.clone();
derniersVerdicts = java.util.List.copyOf(verdicts);
}
public int dernierCompte() {
return dernierCompte;
}
public void vider() {
serie.vider();
}
static double distanceCarreeBoite(double[] p, double[] b) {
double dx = Math.max(0, Math.max(b[0] - p[0], p[0] - b[3]));
double dy = Math.max(0, Math.max(b[1] - p[1], p[1] - b[4]));
double dz = Math.max(0, Math.max(b[2] - p[2], p[2] - b[5]));
return dx * dx + dy * dy + dz * dz;
}
private static double carre(double v) {
return v * v;
}
}
+179
Voir le fichier
@@ -0,0 +1,179 @@
package com.gastinelgarde.core;
/**
* 0.6 (P2.6) : inventaire (ChestStealer, InventoryMove, InvCleaner / AutoArmor). Trois signaux, tous en ticks serveur.
*
* <ol>
* <li><b>vol-de-coffre</b> : dans une même ouverture de conteneur (coffre, tonneau…), des prises (shift-clic ou touche
* de hotbar sur une case du conteneur) d'objets <i>différents</i> commencent moins de {@link GardeConfig#inventaireReactionMinMs}
* après l'ouverture (ping retiré, plafonné) et s'enchaînent à moins de {@link GardeConfig#inventaireIntervalleMaxTicks}
* en moyenne sur au moins {@link GardeConfig#inventairePrisesMin} prises. Le double-clic shift vanilla (même objet,
* même tick) n'est pas compté. Un humain a besoin d'au moins 150 ms pour voir l'écran s'ouvrir et viser la première
* case ; un ChestStealer prend dès la réception. Une fois la session jugée suspecte, <b>chaque</b> prise rapide
* suivante compte (annulable en ENFORCE).</li>
* <li><b>regard-conteneur</b> (contre-contournement « ChestStealer silencieux » / InventoryMove) : le client vanilla ne
* tourne pas la tête quand un écran est ouvert (souris libérée). Une rotation reçue alors que le serveur voit un
* conteneur ouvert, au-delà d'une grâce après l'ouverture, est suspecte. Le stealer « silencieux » ferme l'écran côté
* client seulement : le serveur garde le conteneur ouvert et voit le joueur tourner.</li>
* <li><b>clic-en-rotation</b> (InvCleaner, AutoArmor) : un clic sur l'inventaire du joueur (pas de paquet d'ouverture
* en vanilla) alors que la tête tournait au paquet précédent et au tick d'avant : impossible avec l'écran ouvert.</li>
* </ol>
* Les clics sur un conteneur déjà fermé (identifiant différent, ignorés par vanilla) sont seulement comptés pour le
* journal. Les mods d'inventaire côté client (Mouse Tweaks, Inventory Profiles, Item Scroller) font des rafales de
* shift-clics : c'est pourquoi la réaction après l'ouverture est exigée, et pourquoi le contrôle reste en OBSERVE tant
* qu'il n'a pas été comparé à de vraies sessions. Le mod client InvMove (marcher écran ouvert) ne tourne pas la tête.
*/
public final class Inventaire {
/** Type de clic (sous-ensemble de {@code ClickType} utile ici). */
public enum Clic { PRISE, AUTRE }
// Session d'ouverture d'un conteneur
private boolean ouvert;
private long ouvertTick;
private long premierePriseTick = Long.MIN_VALUE;
private long dernierePriseTick = Long.MIN_VALUE;
private int prises;
private int dernierObjet;
private boolean sessionSuspecte;
private int reactionMs = -1;
// Rotation
private float yaw = Float.NaN, pitch = Float.NaN;
private long rotationTick = Long.MIN_VALUE;
private long rotationAvantTick = Long.MIN_VALUE;
private int rotationsConteneur;
private final SerieFenetre clicsFermes = new SerieFenetre(10, 10_000);
private int dernierCompteFermes;
private String dernierDetail = "";
/** Le serveur vient d'ouvrir un conteneur pour ce joueur (PlayerContainerEvent.Open). */
public void ouvrir(long tick) {
ouvert = true;
ouvertTick = tick;
premierePriseTick = Long.MIN_VALUE;
dernierePriseTick = Long.MIN_VALUE;
prises = 0;
dernierObjet = 0;
sessionSuspecte = false;
reactionMs = -1;
rotationsConteneur = 0;
}
public void fermer() {
ouvert = false;
sessionSuspecte = false;
rotationsConteneur = 0;
}
public boolean ouvert() {
return ouvert;
}
/**
* Clic sur un conteneur ouvert.
*
* @param caseConteneur la case cliquée appartient au conteneur (pas à l'inventaire du joueur)
* @param objet empreinte de l'objet de la case (type d'objet), 0 si vide
* @param pingMs ping mesuré (falsifiable : plafonné par {@link GardeConfig#inventairePingMaxMs})
* @param facteur tolérance (lag) : divise la réaction exigée et l'intervalle maximal
* @return points
*/
public double clicConteneur(long tick, Clic type, boolean caseConteneur, int objet, int pingMs, double facteur,
GardeConfig cfg) {
if (!ouvert || type != Clic.PRISE || !caseConteneur || objet == 0) return 0;
// Double-clic shift vanilla : même objet dans le même tick (toutes les cases de cet objet d'un coup).
if (tick == dernierePriseTick && objet == dernierObjet) return 0;
dernierObjet = objet;
if (prises == 0) {
premierePriseTick = tick;
int ping = Math.max(0, Math.min(pingMs, cfg.inventairePingMaxMs));
reactionMs = (int) Math.max(0, (tick - ouvertTick) * 50 - ping);
}
long ecart = dernierePriseTick == Long.MIN_VALUE ? Long.MAX_VALUE : tick - dernierePriseTick;
dernierePriseTick = tick;
prises++;
// Lag : paquets regroupés (intervalles comprimés) et ticks plus longs que 50 ms : les deux limites se resserrent.
double intervalleMax = cfg.inventaireIntervalleMaxTicks / Math.max(1, facteur);
double reactionMin = cfg.inventaireReactionMinMs / Math.max(1, facteur);
double moyenne = prises <= 1 ? 0 : (double) (tick - premierePriseTick) / (prises - 1);
dernierDetail = String.format(java.util.Locale.ROOT,
"vol-de-coffre : %d prises, reaction %d ms (min %.0f), intervalle moyen %.2f ticks (max %.1f)",
prises, reactionMs, reactionMin, moyenne, intervalleMax);
if (!sessionSuspecte) {
if (prises >= Math.max(2, cfg.inventairePrisesMin) && reactionMs < reactionMin && moyenne <= intervalleMax) {
sessionSuspecte = true;
return 1.0;
}
return 0;
}
// Session déjà suspecte : chaque prise rapide suivante compte.
return ecart <= Math.ceil(intervalleMax) ? 1.0 : 0;
}
/**
* Clic sur l'inventaire du joueur (aucun conteneur ouvert côté serveur) : InvCleaner / AutoArmor si la tête tourne.
*/
public double clicInventaire(long tick, Clic type) {
if (ouvert || type != Clic.PRISE) return 0;
boolean tourne = rotationTick != Long.MIN_VALUE && tick - rotationTick <= 1
&& rotationAvantTick != Long.MIN_VALUE && rotationTick - rotationAvantTick <= 2;
dernierDetail = "clic-en-rotation : clic sur l'inventaire pendant que la tete tourne (dernieres rotations a "
+ (rotationTick == Long.MIN_VALUE ? "?" : String.valueOf(tick - rotationTick)) + " tick(s))";
return tourne ? 0.5 : 0;
}
/** Clic sur un conteneur fermé (identifiant périmé) : journal seulement, quelques-uns arrivent avec le lag. */
public boolean clicFerme(long nowMs) {
dernierCompteFermes = clicsFermes.ajouter(nowMs, true);
return dernierCompteFermes >= 10;
}
public int clicsFermes() {
return dernierCompteFermes;
}
/**
* Rotation reçue (paquet de mouvement accepté).
*
* @param graceTicks grâce après l'ouverture (le client ne voit l'écran qu'après un aller-retour)
* @return points (regard-conteneur)
*/
public double regard(long tick, float nYaw, float nPitch, int graceTicks, GardeConfig cfg) {
boolean change = !Float.isNaN(yaw) && (angle(yaw, nYaw) > 0.5 || Math.abs(nPitch - pitch) > 0.5);
if (Float.isNaN(yaw) || change) {
if (change) {
rotationAvantTick = rotationTick;
rotationTick = tick;
}
yaw = nYaw;
pitch = nPitch;
}
if (!change || !ouvert || tick - ouvertTick <= graceTicks) return 0;
rotationsConteneur++;
dernierDetail = String.format(java.util.Locale.ROOT,
"regard-conteneur : %d rotation(s) avec un conteneur ouvert depuis %d ticks (grace %d)",
rotationsConteneur, tick - ouvertTick, graceTicks);
return rotationsConteneur >= Math.max(1, cfg.inventaireRotationsMin) ? 0.5 : 0;
}
/** Une grâce (téléportation, véhicule…) a remis le regard à zéro : la rotation suivante n'est pas comptée. */
public void oublierRegard() {
yaw = Float.NaN;
rotationsConteneur = 0;
}
public String detail() {
return dernierDetail;
}
public boolean sessionSuspecte() {
return sessionSuspecte;
}
static double angle(float a, float b) {
double d = Math.abs(((b - a) % 360 + 540) % 360 - 180);
return d;
}
}
+34
Voir le fichier
@@ -0,0 +1,34 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.11) : Jesus (marcher sur l'eau ou la lave). Le client vanilla calcule {@code onGround} par collision ; un
* fluide n'a pas de forme de collision : un joueur dans ou sur un fluide, sans bloc ni entité solide sous lui, ne se
* déclare jamais au sol. Le cheat (mode « solide ») se déclare au sol à la surface, sans chute (dy nul).
*
* Le contrôle vol (en ENFORCE en production) attrape déjà la variante tenue au-dessus de la surface (pas de milieu
* spécial, gravité violée) ; celui-ci couvre surtout la variante qui garde les pieds dans le fluide (milieu spécial :
* vol et vitesse ne mesurent pas). Signal : {@link GardeConfig#jesusTicks} (10) paquets d'un tick de suite, au sol
* selon le client, pas au sol selon le serveur, fluide aux pieds ou juste dessous, aucune entité solide sous les pieds
* (bateau, shulker, vaisseau), |dy| < 0,01. Nénuphars, glace (Semelles givrantes), bord du bassin : sol serveur, donc
* rien. OBSERVE par défaut.
*/
public final class Jesus {
private int serie;
public double enregistrer(EtatMouvement m, FaitsMouvement f, GardeConfig cfg) {
boolean suspect = f.surFluide && !f.entiteSolideSous && m.auSolClient() && !m.auSolServeur() && m.ticks() == 1
&& Math.abs(m.dy()) < 0.01;
if (!suspect) {
serie = 0;
return 0;
}
if (++serie < Math.max(1, cfg.jesusTicks)) return 0;
serie = 0;
return 2.0;
}
public void vider() {
serie = 0;
}
}
+652 -6
Voir le fichier
@@ -24,6 +24,45 @@ public final class Moteur {
/** C4 : joueurs déjà expulsés (jusqu'à leur reconnexion). */
private final java.util.Set<UUID> expulses = new java.util.HashSet<>();
private java.util.function.LongSupplier horloge = System::currentTimeMillis;
private final HistoriqueSuspicion historique = new HistoriqueSuspicion();
/** Horloge du score de suspicion (ms) ; remplaçable dans les tests. */
public void horloge(java.util.function.LongSupplier h) {
this.horloge = h;
}
public HistoriqueSuspicion historique() {
return historique;
}
/** Alerte de suspicion : franchissement vers le haut d'un palier. */
public record AlerteSuspicion(Suspicion.Niveau niveau, int score, int incidents, String controles) { }
/**
* Franchissement de palier en attente pour ce joueur (null sinon). À partir de « suspect », l'incident est ajouté à
* l'historique. Aucune sanction ici : c'est une information pour les humains.
*/
public AlerteSuspicion alerteSuspicion(UUID joueur, long epochMs) {
Suivi s = suivis.get(joueur);
if (s == null) return null;
Suspicion.Niveau n = s.suspicion.prendreTransition();
if (n == null) return null;
long now = horloge.getAsLong();
int score = (int) Math.round(s.suspicion.score(now));
String ctl = s.suspicion.resume(now);
if (n.ordinal() >= Suspicion.Niveau.SUSPECT.ordinal()) {
historique.enregistrer(joueur, epochMs, n, score, ctl);
}
return new AlerteSuspicion(n, score, historique.incidents(joueur, epochMs, cfg.suspicionHistoriqueJours), ctl);
}
/** Score courant d'un joueur suivi (0 si inconnu). */
public double scoreSuspicion(UUID joueur) {
Suivi s = suivis.get(joueur);
return s == null ? 0 : s.suspicion.score(horloge.getAsLong());
}
public Moteur(GardeConfig cfg) {
this.cfg = cfg;
}
@@ -33,7 +72,7 @@ public final class Moteur {
}
public Suivi suivi(UUID joueur) {
return suivis.computeIfAbsent(joueur, k -> new Suivi(cfg.vlDecroissanceParSeconde));
return suivis.computeIfAbsent(joueur, k -> new Suivi(cfg.vlDecroissanceParSeconde, cfg));
}
public void retirer(UUID joueur) {
@@ -329,24 +368,48 @@ public final class Moteur {
* 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) {
return mouvement(joueur, nowMs, etat, m, Double.NaN);
}
/**
* Idem, avec la hauteur de marche permise du joueur pour le contrôle step (0.5, P1.9) : max(attribut step_height,
* puissance de saut). NaN = inconnue (traces, rejeu, piston proche) : step ne mesure pas.
*/
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m, double hauteurPermise) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
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();
boolean step = cfg.mode(Controle.STEP) != Mode.OFF;
boolean criticals = cfg.mode(Controle.CRITICALS) != Mode.OFF;
boolean antiFaim = cfg.mode(Controle.ANTI_FAIM) != Mode.OFF;
if (!noFall && !vitesse && !vol && !step && !criticals && !antiFaim) return List.of();
Suivi s = suivi(joueur);
if (criticals) s.criticals.mouvement(m); // 0.5 (P1.10) : hauteur suivie même pendant une exemption
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
if (ex.exempt()) {
s.step.vider();
s.antiFaim.vider();
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
s.vol.vider();
// 0.4.0 : plané seul exempté -> contrôle « elytres » (Elytra Hack). Toute autre exemption l'écarte.
List<Verdict> plane = new ArrayList<>(1);
if (ex.raisons().size() == 1 && ex.raisons().get(0).equals("elytres")
&& cfg.mode(Controle.ELYTRES) != Mode.OFF) {
ajouter(plane, s, Controle.ELYTRES, s.plane.enregistrer(m, etat.propulsionRecente(), cfg), nowMs, ex,
String.format(Locale.ROOT, "plane dxz=%.3f dy=%.3f ticks=%d", m.dxz(), m.dy(), m.ticks()));
} else {
s.plane.vider();
}
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
if (ex.raisons().contains("elytres")) {
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
}
return List.of();
return plane;
}
s.plane.vider(); // plus en plané (atterrissage, fin des élytres) : ni référence de vitesse ni compteur gardés
List<Verdict> verdicts = new ArrayList<>(3);
if (noFall) {
ajouter(verdicts, s, Controle.NO_FALL, NoFall.points(m), nowMs, ex,
@@ -369,19 +432,437 @@ public final class Moteur {
s.vol.vider(); // le paquet qui suit la grâce sert de référence
} else if (vol) {
s.vol.fenetreGlissante = cfg.volFenetreGlissante; // C10, désactivé par défaut
s.vol.flottementMax = cfg.volFlottementTicks; // 0.4.0 : flottement prolongé (80 ticks comme vanilla)
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()));
}
if (step) {
double pts = s.step.enregistrer(m, hauteurPermise, cfg);
ajouter(verdicts, s, Controle.STEP, pts, nowMs, ex, String.format(Locale.ROOT,
"marche de %.3f en un tick au sol (seuil %.2f)", m.dy(), Step.seuil(hauteurPermise, cfg)));
}
if (antiFaim) {
ajouter(verdicts, s, Controle.ANTI_FAIM, s.antiFaim.enregistrer(m, cfg), nowMs, ex, String.format(Locale.ROOT,
"course au sol declaree en l'air %d paquets de suite (dxz=%.3f)", cfg.antiFaimTicks, m.dxz()));
}
return verdicts;
}
/**
* 0.5 (P2) : contrôles de mouvement ajoutés en P2 (no-slow…), sur le même paquet accepté que {@link #mouvement},
* avec les faits supplémentaires lus par l'adaptateur. Appel séparé pour ne pas toucher la signature de
* {@link #mouvement} (traces, rejeu). Mêmes exemptions de mouvement : créatif, spectateur, vol permis, élytres,
* riptide, véhicule, contraption Create / vaisseau Sable, téléportation, recul, connexion ; seuils × facteurLag si
* le serveur tire.
*/
public List<Verdict> mouvementP2(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m, FaitsMouvement f) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
boolean noSlow = cfg.mode(Controle.NO_SLOW) != Mode.OFF;
boolean jesus = cfg.mode(Controle.JESUS) != Mode.OFF;
boolean omni = cfg.mode(Controle.OMNISPRINT) != Mode.OFF;
if (!noSlow && !jesus && !omni) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
if (ex.exempt() || etat.ticksDepuisGel() <= cfg.graceGelTicks) {
s.noSlow.vider();
s.jesus.vider();
s.omnisprint.vider();
return List.of();
}
List<Verdict> verdicts = new ArrayList<>(2);
if (jesus) {
ajouter(verdicts, s, Controle.JESUS, s.jesus.enregistrer(m, f, cfg), nowMs, ex, String.format(Locale.ROOT,
"au sol declare sur un fluide sans appui %d paquets de suite (dy=%.3f)", cfg.jesusTicks, m.dy()));
}
if (omni) {
ajouter(verdicts, s, Controle.OMNISPRINT, s.omnisprint.enregistrer(m, f, cfg), nowMs, ex, String.format(Locale.ROOT,
"sprint a %.0f deg du regard %d paquets de suite (max %.0f)", s.omnisprint.dernierAngle(),
cfg.omnisprintTicks, cfg.omnisprintAngleDegres));
}
if (noSlow) {
double pts = s.noSlow.enregistrer(m, f.ticksUsage, cfg, ex.facteur());
ajouter(verdicts, s, Controle.NO_SLOW, pts, nowMs, ex, String.format(Locale.ROOT,
"vitesse %.3f au sol en utilisant un objet %d paquets de suite (seuil %.3f)",
s.noSlow.derniereVitesse(), cfg.noSlowTicks, NoSlow.seuil(m, cfg)));
}
return verdicts;
}
// --- 0.5 (P2) : casse et pose de blocs -------------------------------------------------------------
/** START_DESTROY_BLOCK accepté (non annulé par un mod) : début de la mesure fast-break. */
public void debutCasse(UUID joueur, long tick, int x, int y, int z) {
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return;
suivi(joueur).fastBreak.debut(tick, x, y, z);
}
/**
* Un bloc vient d'être cassé par le joueur (BlockEvent.BreakEvent).
*
* @param progression {@code getDestroyProgress} du bloc pour ce joueur (par tick) ; NaN si inconnue
*/
public List<Verdict> casseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat, int x, int y, int z, double progression) {
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt() || etat.tps() < cfg.tpsLag) {
s.fastBreak.vider();
return List.of();
}
double pts = s.fastBreak.casse(nowMs, tick, x, y, z, progression, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.FAST_BREAK, pts, nowMs, ex, String.format(Locale.ROOT,
"bloc casse a %.2f du temps vanilla (seuil %.2f), %d casses suspectes sur %d",
s.fastBreak.dernierRapport(), cfg.fastBreakFacteur, s.fastBreak.dernierCompte(), FastBreak.SERIE));
return v;
}
/**
* 0.5 (P2.10) : bloc cassé, pour la statistique x-ray (alerte seulement). Pas d'exemption de lag : rien n'y est
* mesuré en temps ; créatif et spectateur exemptés.
*/
public List<Verdict> casseXray(UUID joueur, long nowMs, EtatJoueur etat, int y, boolean rare, boolean expose) {
if (expulses.contains(joueur) || cfg.mode(Controle.XRAY) == Mode.OFF) return List.of();
if (etat.creatif() || etat.spectateur()) return List.of();
Suivi s = suivi(joueur);
List<Verdict> v = new ArrayList<>(1);
double pts = s.xray.casse(y, rare, expose, cfg);
if (pts > 0) ajouter(v, s, Controle.XRAY, pts, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE), s.xray.resume());
return v;
}
/** 0.6.1 (revue M2) : paquet de casse (START/STOP/ABORT) du joueur sur ce bloc ({@code BlockPos.asLong}). */
public void paquetCasse(UUID joueur, long cleBloc, long nowMs) {
if (expulses.contains(joueur)) return;
suivi(joueur).paquetsCasse.noter(cleBloc, nowMs);
}
/**
* 0.6.1 (revue M2) : cette casse est-elle hors du nuker ? Vrai seulement si {@code nukerIgnorerCassesSansPaquet} est
* activé et qu'aucun paquet de casse du joueur n'a visé ce bloc dans le même tick (casse en chaîne d'un mod).
*/
public boolean casseNukerSansPaquet(UUID joueur, long cleBloc, long nowMs) {
if (!cfg.nukerIgnorerCassesSansPaquet) return false;
Suivi s = suivis.get(joueur);
return s == null || !s.paquetsCasse.contient(cleBloc, nowMs, 0);
}
/** 0.6.1 (revue M3) : un bloc proche de ce joueur vient de changer (casse, pose, cible d'un clic de pose). */
public void changementBloc(UUID joueur, long cleBloc, long nowMs) {
if (expulses.contains(joueur)) return;
suivi(joueur).changementsBloc.noter(cleBloc, nowMs);
}
/**
* 0.5 (P3.3) : bloc cassé par le joueur, pour le nuker (plusieurs blocs dans le même tick serveur). Exemptions de la
* famille MONDE (créatif, spectateur, contraption, vaisseau, gel) ; TPS bas : pas de mesure (paquets groupés).
*/
public List<Verdict> casseNuker(UUID joueur, long nowMs, long tick, EtatJoueur etat) {
if (expulses.contains(joueur) || cfg.mode(Controle.NUKER) == Mode.OFF) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt() || etat.tps() < cfg.tpsLag) {
s.nuker.vider();
return List.of();
}
double pts = s.nuker.casse(nowMs, tick, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.NUKER, pts, nowMs, ex, String.format(Locale.ROOT,
"%d blocs casses dans le meme tick (max %d), %d ticks suspects sur %d", s.nuker.casses(),
cfg.nukerBlocsParTickMax, s.nuker.dernierCompte(), Nuker.SERIE));
for (Verdict x : v) {
if (x.applicable().ordinal() >= Sanction.SETBACK.ordinal()) s.nuker.marquerAnnulation();
}
return v;
}
/**
* 0.5 (P3.3, revue de sécurité) : la casse qui vient d'être mesurée par {@link #casseNuker} doit-elle être annulée ?
* Vrai pour chaque casse excédentaire du tick (pas seulement la première) quand ce tick a donné une sanction
* ≥ SETBACK applicable, ou quand le contrôle est en ENFORCE et que le VL nuker est déjà au palier SETBACK. Jamais
* en OBSERVE.
*/
public boolean nukerAnnulerCasse(UUID joueur, long nowMs, long tick) {
if (cfg.mode(Controle.NUKER) != Mode.ENFORCE) return false;
Suivi s = suivis.get(joueur);
if (s == null || !s.nuker.excedent(tick, cfg)) return false;
if (s.nuker.annulerTick()) return true;
Sanction palier = Paliers.palier(s.vl.valeur(Controle.NUKER, nowMs), cfg, Controle.NUKER);
return Paliers.applicable(palier, Mode.ENFORCE).ordinal() >= Sanction.SETBACK.ordinal();
}
/**
* 0.5 (P3.1) : coup sur un cristal de l'End d'âge connu ({@code ageTicks} négatif = inconnu, non mesuré).
* Exemptions de la famille COMBAT ; TPS bas : pas de mesure (paquets groupés).
*/
public List<Verdict> frappeCristal(UUID joueur, long nowMs, EtatJoueur etat, int ageTicks) {
if (expulses.contains(joueur) || cfg.mode(Controle.AUTO_CRISTAL) == Mode.OFF) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
if (ex.exempt() || etat.tps() < cfg.tpsLag || etat.ticksDepuisGel() <= cfg.graceGelTicks) return List.of();
double pts = s.autoCristal.frappe(nowMs, ageTicks, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.AUTO_CRISTAL, pts, nowMs, ex, String.format(Locale.ROOT,
"cristal frappe a %d tick(s) de son apparition (min %d), %d coups suspects sur %d", ageTicks,
cfg.cristalDelaiMinTicks, s.autoCristal.dernierCompte(), AutoCristal.SERIE));
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;
}
// --- 0.6 : inventaire, scaffold horizontal, blink, phase (OBSERVE par défaut) ---------------------------
private boolean actif(UUID joueur, Controle c) {
return !expulses.contains(joueur) && cfg.mode(c) != Mode.OFF;
}
/** 0.6 (P2.6) : le serveur ouvre un conteneur (coffre, tonneau…) pour ce joueur. */
public void ouvrirConteneur(UUID joueur, long tick) {
if (actif(joueur, Controle.INVENTAIRE)) suivi(joueur).inventaire.ouvrir(tick);
}
/** 0.6 (P2.6) : conteneur fermé (par le joueur, le serveur ou la distance). */
public void fermerConteneur(UUID joueur) {
Suivi s = suivis.get(joueur);
if (s != null) s.inventaire.fermer();
}
/**
* 0.6 (P2.6) : clic de conteneur reçu (après ensureRunningOnSameThread).
*
* @param idValide l'identifiant du paquet est celui du menu ouvert côté serveur (sinon vanilla l'ignore)
* @param menuConteneur un conteneur est ouvert côté serveur (pas l'inventaire du joueur)
* @param caseConteneur la case cliquée appartient au conteneur
* @param objet empreinte du type d'objet de la case (0 si vide)
*/
public List<Verdict> clicConteneur(UUID joueur, long nowMs, long tick, EtatJoueur etat, boolean idValide,
boolean menuConteneur, Inventaire.Clic type, boolean caseConteneur, int objet) {
if (!actif(joueur, Controle.INVENTAIRE)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt()) return List.of();
double f = etat.tps() < cfg.tpsLag ? Math.max(ex.facteur(), cfg.facteurLag) : ex.facteur();
List<Verdict> v = new ArrayList<>(1);
if (!idValide) {
if (s.inventaire.clicFerme(nowMs)) {
// journal seulement (points minimes) : le lag après une fermeture en produit quelques-uns
ajouter(v, s, Controle.INVENTAIRE, 0.1, nowMs, ex, "clic-ferme : " + s.inventaire.clicsFermes()
+ " clics sur un conteneur deja ferme en 10 s (ignores par vanilla)");
}
return v;
}
double pts;
if (menuConteneur) {
pts = s.inventaire.clicConteneur(tick, type, caseConteneur, objet, etat.pingMs(), f, cfg);
} else {
Exemptions.Resultat exM = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
pts = exM.exempt() ? 0 : s.inventaire.clicInventaire(tick, type);
}
ajouter(v, s, Controle.INVENTAIRE, pts, nowMs, ex, s.inventaire.detail());
return v;
}
/** 0.6 (P2.6) : rotation acceptée ; compte celles reçues avec un conteneur ouvert (InventoryMove, stealer silencieux). */
public List<Verdict> regardInventaire(UUID joueur, long nowMs, long tick, EtatJoueur etat, float yaw, float pitch) {
if (!actif(joueur, Controle.INVENTAIRE)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
Exemptions.Resultat exW = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt() || exW.exempt() || etat.tps() < cfg.tpsLag) {
s.inventaire.oublierRegard();
return List.of();
}
// Ping élevé : le client voit l'écran s'ouvrir un aller-retour plus tard (plafonné : le ping est falsifiable).
int grace = cfg.inventaireGraceRotationTicks + Math.min(Math.max(0, etat.pingMs()), cfg.inventairePingMaxMs * 2) / 50;
double pts = s.inventaire.regard(tick, yaw, pitch, grace, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.INVENTAIRE, pts, nowMs, ex, s.inventaire.detail());
return v;
}
/** 0.6 (P3.2) : pose d'un bloc de pont (voir {@link Scaffold#estPont}) ; jugée au paquet de mouvement suivant. */
public void poseScaffold(UUID joueur, EtatJoueur etat, float dirYaw, float dirPitch, float yawAvant,
float pitchAvant, float yawPose, float pitchPose) {
if (!actif(joueur, Controle.SCAFFOLD)) return;
Suivi s = suivi(joueur);
if (Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE).exempt()
|| Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT).exempt() || etat.tps() < cfg.tpsLag) {
s.scaffold.vider();
return;
}
s.scaffold.pose(dirYaw, dirPitch, yawAvant, pitchAvant, yawPose, pitchPose);
}
/** 0.6 (P3.2) : vrai si une pose de pont doit être annulée (ENFORCE, période suspecte, VL au palier SETBACK). */
public boolean scaffoldAnnuler(UUID joueur, long nowMs, long tick) {
if (cfg.mode(Controle.SCAFFOLD) != Mode.ENFORCE) return false;
Suivi s = suivis.get(joueur);
if (s == null || !s.scaffold.suspect(tick)) return false;
return Paliers.palier(s.vl.valeur(Controle.SCAFFOLD, nowMs), cfg, Controle.SCAFFOLD).ordinal() >= Sanction.SETBACK.ordinal();
}
/** 0.6 (P3.2) : paquet de mouvement accepté : juge la dernière pose de pont, s'il y en a une. */
public List<Verdict> regardScaffold(UUID joueur, long nowMs, long tick, float yaw, float pitch) {
if (!actif(joueur, Controle.SCAFFOLD)) return List.of();
Suivi s = suivis.get(joueur);
if (s == null) return List.of();
double pts = s.scaffold.regard(tick, nowMs, yaw, pitch, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.SCAFFOLD, pts, nowMs, new Exemptions.Resultat(false, 1.0, List.of()), s.scaffold.detail());
return v;
}
/** 0.6 (P3.4) : autre paquet traité sur le thread serveur (coup, clic sur un bloc, conteneur, complétion). */
public void autrePaquet(UUID joueur, long tick) {
if (!actif(joueur, Controle.BLINK)) return;
suivi(joueur).blink.autrePaquet(tick);
}
/** 0.6 (P3.4) : paquet de mouvement reçu (avant traitement). Exemptions TIMER, véhicule, mort, gel, TPS bas. */
public List<Verdict> mouvementBlink(UUID joueur, long nowMs, long tick, EtatJoueur etat, boolean vivant) {
if (!actif(joueur, Controle.BLINK)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
if (ex.exempt() || !vivant || etat.enVehicule() || etat.ticksDepuisGel() <= cfg.graceGelTicks
|| etat.tps() < cfg.tpsLag) {
s.blink.vider();
return List.of();
}
double pts = s.blink.mouvement(tick, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.BLINK, pts, nowMs, ex, String.format(Locale.ROOT,
"trou de %d ticks sans mouvement, %d autre(s) paquet(s) recus pendant le trou (min %d, trou min %d)",
s.blink.dernierTrou(), s.blink.dernierAutres(), cfg.blinkAutresMin, cfg.blinkTrouMinTicks));
return v;
}
/** 0.6 (P3.5) : paquet de mouvement refusé par vanilla ; {@code dansBloc} si la boîte déclarée chevauche un bloc. */
public List<Verdict> refusPhase(UUID joueur, long nowMs, EtatJoueur etat, boolean dansBloc, double distance) {
if (!actif(joueur, Controle.PHASE)) return List.of();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT);
Exemptions.Resultat exW = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt() || exW.exempt() || etat.tps() < cfg.tpsLag) return List.of();
double pts = s.phase.refus(nowMs, dansBloc, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.PHASE, pts, nowMs, ex, String.format(Locale.ROOT,
"position refusee par vanilla dans un bloc solide (%.2f bloc(s) de la position acceptee), %d en 10 s (min %d)",
distance, s.phase.compte(), cfg.phaseSerieMin));
return v;
}
/**
* 0.5 (P3.7) : demande de complétion de commande reçue (horloge réelle : plusieurs paquets par tick). Aucune
* exemption de jeu (rien ne dépend du mouvement). Voir {@link #completionAIgnorer}.
*/
public List<Verdict> completion(UUID joueur, long nowMs, EtatJoueur etat) {
if (expulses.contains(joueur) || cfg.mode(Controle.COMPLETION) == Mode.OFF) return List.of();
Suivi s = suivi(joueur);
boolean exces = s.completion.demande(nowMs, cfg);
s.completionExces = exces;
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.COMPLETION, exces ? 0.25 : 0, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER),
String.format(Locale.ROOT, "demande de completion au-dela de %d/s (rafale %d), %d en exces depuis la connexion",
cfg.completionParSecondeMax, cfg.completionRafaleMax, s.completion.excesTotal()));
return v;
}
/** La dernière demande de complétion était en excès et le contrôle est en ENFORCE : le paquet est ignoré. */
public boolean completionAIgnorer(UUID joueur) {
if (expulses.contains(joueur)) return true;
Suivi s = suivis.get(joueur);
return s != null && s.completionExces && cfg.mode(Controle.COMPLETION) == Mode.ENFORCE;
}
/** 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();
Suivi s = suivi(joueur);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt()) {
s.fastPlace.vider();
return List.of();
}
double pts = s.fastPlace.pose(tick, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.FAST_PLACE, pts, nowMs, ex, String.format(Locale.ROOT,
"%d poses a intervalle regulier de %d tick(s) (vanilla au clic maintenu : 4)", cfg.fastPlaceSerie,
s.fastPlace.dernierIntervalle()));
return v;
}
/**
* Clic sur un bloc (RightClickBlock, ou début de casse sans impact) : interaction-bloc. Voir
* {@link InteractionBloc#anomalie} pour les paramètres géométriques.
*/
public List<Verdict> interactionBloc(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] boite, int face,
double[] impact, boolean air, boolean plein, double portee, double deplacement) {
return interactionBloc(joueur, nowMs, Long.MIN_VALUE, -1, etat, oeil, boite, face, impact, air, plein, portee, deplacement);
}
/**
* Idem, avec la position du bloc ({@code BlockPos.asLong}) et la main (0 principale, 1 secondaire, -1 inconnue).
* Seconde revue de sécurité : seul le clic vanilla « main principale puis secondaire » (même instant, bloc, face et
* impact, une fois par instant) n'est compté qu'une fois ; la main secondaire reprend alors les verdicts de la
* principale, donc la même décision d'annulation. Tout autre événement est évalué normalement.
*/
public List<Verdict> interactionBloc(UUID joueur, long nowMs, long cleBloc, int main, EtatJoueur etat, double[] oeil,
double[] boite, int face, double[] impact, boolean air, boolean plein, double portee,
double deplacement) {
if (expulses.contains(joueur) || cfg.mode(Controle.INTERACTION_BLOC) == Mode.OFF) return List.of();
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
if (ex.exempt()) return List.of();
Suivi s = suivi(joueur);
double marge = (cfg.interactionBlocMarge + Math.max(0, Math.min(deplacement, 5.0))) * ex.facteur();
String a = InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, portee, marge);
// 0.6.1 (revue M3) : bloc fantôme (le client voit encore un bloc que le serveur vient de casser, ou une pose
// refusée) : « bloc-vide » n'est pas compté si ce bloc a changé il y a peu.
if ("bloc-vide".equals(a) && cleBloc != Long.MIN_VALUE
&& s.changementsBloc.contient(cleBloc, nowMs, Math.max(0, cfg.interactionBlocGraceChangementMs))) {
a = null;
}
// La vérification tourne toujours ; seul le comptage est sauté pour la main secondaire du même clic, et seulement
// si elle donne la même anomalie que la principale : elle reprend alors ses verdicts (même décision d'annulation).
if (cleBloc != Long.MIN_VALUE && s.interactionBloc.secondeMainDuMemeClic(nowMs, cleBloc, main, face, impact)
&& java.util.Objects.equals(a, s.interactionBloc.derniereAnomalie())) {
return new ArrayList<>(s.interactionBloc.reprendre(nowMs));
}
double pts = s.interactionBloc.enregistrer(nowMs, a, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.INTERACTION_BLOC, pts, nowMs, ex, String.format(Locale.ROOT,
"%s (%s), %d anomalies sur %d interactions", a, impact == null ? "debut de casse" : "clic droit",
s.interactionBloc.dernierCompte(), InteractionBloc.SERIE));
s.interactionBloc.memoriser(nowMs, cleBloc, main, face, impact, a, v);
return v;
}
/**
* L'exemption tient-elle à un état dont la fin arrive en retard côté serveur (élytres, riptide, véhicule, vol,
* contraption, lévitation, chute lente, mode de jeu) ? Une grâce seule (téléportation, recul) : non.
*/
static boolean sortieDEtat(List<String> raisons) {
for (String r : raisons) {
if (!r.equals("teleportation") && !r.equals("recul")) return true;
if (!r.equals("teleportation") && !r.equals("recul") && !r.equals("connexion")) return true;
}
return false;
}
@@ -436,6 +917,113 @@ public final class Moteur {
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
}
// --- 0.4.0 : vélocité (recul) et auto-totem ---
/**
* Le serveur applique un recul au joueur (coup, explosion, charge de vent).
*
* @param dirX,dirZ direction du déplacement attendu ; {@code force} effective, résistance déduite
*/
public void reculApplique(UUID joueur, long nowMs, double dirX, double dirZ, double force, boolean libre) {
if (cfg.mode(Controle.VELOCITE) == Mode.OFF || expulses.contains(joueur)) return;
// Joueur coincé (mur, trou, plafond) : le recul n'a pas pu avoir lieu, rien à mesurer.
if (!libre) {
suivi(joueur).velocite.abandonner();
return;
}
suivi(joueur).velocite.recul(nowMs, dirX, dirZ, force, cfg);
}
/**
* 0.5 (P1.6) : le joueur vient de passer en plané (transition vue par le serveur entre deux paquets de
* mouvement). Contrôle « elytres » : déploiements trop fréquents (ElytraFly « packet »).
*/
public List<Verdict> deploiementElytres(UUID joueur, long nowMs, EtatJoueur etat) {
if (expulses.contains(joueur) || cfg.mode(Controle.ELYTRES) == Mode.OFF) return List.of();
if (etat.creatif() || etat.spectateur() || etat.peutVoler()) return List.of();
Suivi s = suivi(joueur);
double pts = s.deploiements.deploiement(nowMs, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.ELYTRES, pts, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT),
String.format(Locale.ROOT, "%d deploiements d'elytres en 1 s (max %d)", s.deploiements.dernierCompte(),
cfg.elytresDeploiementsMax));
return v;
}
/** Nouvelle fusée tirée en plané par ce joueur : le gain de vitesse est mesuré depuis zéro. */
public void nouvelleFusee(UUID joueur) {
suivi(joueur).plane.nouvelleFusee();
}
/** Déplacement horizontal de ce paquet accepté (dx, dz signés), pour mesurer le recul en cours. */
public List<Verdict> mesureRecul(UUID joueur, long nowMs, EtatJoueur etat, double dx, double dz, boolean milieuSpecial,
java.util.function.BiPredicate<Double, Double> bloqueDansLeSens) {
if (cfg.mode(Controle.VELOCITE) == Mode.OFF || expulses.contains(joueur)) return List.of();
Suivi s = suivis.get(joueur);
if (s == null) return List.of();
boolean neutre = milieuSpecial || etat.ticksDepuisGel() <= cfg.graceGelTicks
|| etat.tps() < cfg.tpsLag || etat.creatif() || etat.spectateur() || etat.peutVoler() || etat.elytres()
|| etat.enVehicule() || etat.riptide() || etat.pocheContraption()
|| etat.ticksDepuisTeleport() <= cfg.graceTeleportTicks;
// Collision testée seulement dans le sens du recul (le prédicat n'est évalué que pendant une mesure) : se coller
// à un mur ailleurs n'annule rien.
boolean bloque = s.velocite.actif() && bloqueDansLeSens.test(s.velocite.dirX(), s.velocite.dirZ());
double pts = s.velocite.mouvement(nowMs, dx, dz, neutre, bloque, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.VELOCITE, pts, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT),
"recul absent apres un coup subi (serie)");
return v;
}
/** Un totem vient d'éclater ; {@code reserveEnMain} : un autre totem est déjà dans l'autre main. */
public void totemEclate(UUID joueur, long nowMs, boolean reserveEnMain) {
if (!totemMesure() || expulses.contains(joueur)) return;
suivi(joueur).totem.eclatement(nowMs, reserveEnMain);
}
/** Contenu des mains (au moins un totem ?) à un paquet de mouvement après un éclatement. */
public List<Verdict> totemEnMain(UUID joueur, long nowMs, EtatJoueur etat, boolean totemEnMain) {
if (!totemMesure() || expulses.contains(joueur)) return List.of();
Suivi s = suivis.get(joueur);
if (s == null) return List.of();
List<Verdict> v = new ArrayList<>(1);
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
double pts = s.totem.mains(nowMs, totemEnMain, etat.pingMs(), cfg);
if (cfg.mode(Controle.AUTO_TOTEM) != Mode.OFF) {
ajouter(v, s, Controle.AUTO_TOTEM, pts, nowMs, ex, "totem remis en main trop vite apres l'eclatement");
}
// 0.5 (P2.7) : distribution des délais (contrôle séparé, OBSERVE par défaut).
long delai = s.totem.prendreDelai();
if (delai >= 0 && cfg.mode(Controle.AUTO_TOTEM_REGULIER) != Mode.OFF) {
double p2 = s.totemRegulier.delai(delai, cfg);
ajouter(v, s, Controle.AUTO_TOTEM_REGULIER, p2, nowMs, ex, String.format(Locale.ROOT,
"%d derniers totems remis en %.0f ms en moyenne, ecart type %.1f ms (min %d)", cfg.autoTotemEchantillons,
s.totemRegulier.derniereMoyenne(), s.totemRegulier.dernierEcartType(), cfg.autoTotemEcartTypeMinMs));
}
return v;
}
/** Auto-totem ou sa variante « régulier » (P2.7) actifs : l'éclatement est suivi. */
private boolean totemMesure() {
return cfg.mode(Controle.AUTO_TOTEM) != Mode.OFF || cfg.mode(Controle.AUTO_TOTEM_REGULIER) != Mode.OFF;
}
/**
* 0.5 (P1.10) : coup critique vanilla accordé par le serveur (CriticalHitEvent). Suspect s'il ne vient d'aucun
* vrai saut ni d'aucune vraie chute (voir {@link Criticals}). En ENFORCE, l'adaptateur annule le critique au palier
* SETBACK ; l'expulsion s'applique comme pour les autres contrôles de combat.
*/
public List<Verdict> critique(UUID joueur, long nowMs, EtatJoueur etat) {
if (expulses.contains(joueur) || cfg.mode(Controle.CRITICALS) == Mode.OFF) return List.of();
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
if (ex.exempt()) return List.of();
Suivi s = suivi(joueur);
double pts = s.criticals.coup(nowMs, cfg);
List<Verdict> v = new ArrayList<>(1);
ajouter(v, s, Controle.CRITICALS, pts, nowMs, ex, String.format(Locale.ROOT,
"critique sans vrai saut (montee %.3f, descente %.3f), %d critiques suspects sur %d",
s.criticals.haut(), -s.criticals.bas(), s.criticals.dernierCompte(), Criticals.SERIE));
return v;
}
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
/**
@@ -443,13 +1031,45 @@ public final class Moteur {
* paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5).
*/
public void apresSetback(UUID joueur, long nowMs) {
apresSetback(joueur, nowMs, List.of());
}
/**
* 0.6.1 (revue M4) : idem, et le VL de chaque contrôle qui a demandé ce setback (verdict applicable ≥ SETBACK) est
* aussi remis à zéro. Avant, step, no-slow ou jesus restaient au-dessus du seuil et redonnaient un setback à chaque
* paquet, jusqu'à l'expulsion. Le setback est noté pour l'escalade et pour {@link #setbackDejaApplique} (M1).
*/
public void apresSetback(UUID joueur, long nowMs, List<Verdict> causes) {
Suivi s = suivi(joueur);
s.vol.vider();
s.vitesse.vider();
s.graceElytresJusquaMs = Long.MIN_VALUE;
s.vl.remettreAZero(Controle.VOL);
s.vl.remettreAZero(Controle.VITESSE);
remettreAZeroCauses(s, causes);
s.noterSetback(nowMs);
s.dernierSetbackMs = nowMs;
}
/**
* 0.6.1 (revue M1) : un setback a-t-il déjà été appliqué à cet instant (même tick serveur) ? Un même paquet peut
* donner SETBACK sur vol puis sur jesus/no-slow : un seul retour et un seul compte pour l'escalade.
*/
public boolean setbackDejaApplique(UUID joueur, long nowMs) {
Suivi s = suivis.get(joueur);
return s != null && s.dernierSetbackMs == nowMs;
}
/** 0.6.1 (revue M1/M4) : second setback du même tick : seuls les VL de ses causes sont remis à zéro. */
public void apresSetbackDuMemeTick(UUID joueur, List<Verdict> causes) {
remettreAZeroCauses(suivi(joueur), causes);
}
private static void remettreAZeroCauses(Suivi s, List<Verdict> causes) {
if (causes == null) return;
for (Verdict v : causes) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) s.vl.remettreAZero(v.controle());
}
}
/**
@@ -457,7 +1077,25 @@ public final class Moteur {
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
*/
public boolean expulser(UUID joueur, long nowMs) {
return expulses.add(joueur);
boolean premiere = expulses.add(joueur);
if (premiere) derniereExpulsionMs.put(joueur, nowMs);
return premiere;
}
/** 0.5 (P1.2) : une expulsion compte comme « récente » pour la grâce de reconnexion pendant cette durée. */
public static final long EXPULSION_RECENTE_MS = 10 * 60_000L;
/** Instant (ms, horloge des ticks) de la dernière expulsion de chaque joueur ; survit à la reconnexion. */
private final Map<UUID, Long> derniereExpulsionMs = new HashMap<>();
/**
* 0.5 (P1.2) : durée de la grâce de connexion (ticks) : {@code graceApresExpulsionTicks} si le joueur a été
* expulsé il y a moins de {@link #EXPULSION_RECENTE_MS}, sinon {@code graceConnexionTicks}.
*/
public int graceConnexionTicks(UUID joueur, long nowMs) {
derniereExpulsionMs.values().removeIf(t -> nowMs - t > EXPULSION_RECENTE_MS || nowMs < t);
Long t = derniereExpulsionMs.get(joueur);
int base = Math.max(0, cfg.graceConnexionTicks);
return t != null ? Math.max(base, cfg.graceApresExpulsionTicks) : base;
}
public boolean estExpulse(UUID joueur) {
@@ -486,13 +1124,21 @@ public final class Moteur {
if (points <= 0) return;
Mode mode = cfg.mode(c);
double vl = s.vl.ajouter(c, points, nowMs);
Sanction palier = Paliers.palier(vl, cfg);
Sanction palier = Paliers.palier(vl, cfg, c); // 0.4.2 : seuils propres a auto-totem et velocite
// C5 (16/10) : après un setback, le VL repart de zéro ; l'expulsion vient après plusieurs setbacks récents.
if (palier == Sanction.SETBACK && cfg.setbacksAvantExpulsion > 0
&& s.setbacksRecents(nowMs, cfg.fenetreSetbacksMs) >= cfg.setbacksAvantExpulsion) {
palier = Sanction.min(Sanction.EXPULSION, cfg.sanctionMax);
}
Sanction applicable = Paliers.applicable(palier, mode);
// 0.4.0 : vélocité et auto-totem sont bridés dans le code (un tiers peut provoquer de faux positifs) : jamais de
// setback ni d'expulsion, même si la configuration les passe en ENFORCE. Ils nourrissent le score de suspicion.
// 0.4.2 (decision de Theo) : vraies sanctions en ENFORCE. Auto-totem n'a pas de retour en arriere qui ait un
// sens : son palier SETBACK reste une ALERTE, l'expulsion s'applique. Velocite : SETBACK = retour en arriere.
if (c == Controle.AUTO_TOTEM && applicable == Sanction.SETBACK) applicable = Sanction.ALERTE;
// 0.5 (P2.10) : x-ray statistique, jamais au-delà de l'alerte (un minage chanceux reste possible).
if (c == Controle.XRAY) applicable = Sanction.min(applicable, Sanction.ALERTE);
s.suspicion.noter(c, vl, palier.ordinal() >= Sanction.SETBACK.ordinal(), horloge.getAsLong());
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
sortie.add(new Verdict(c, mode, points, vl, palier, applicable, notifier, details, ex.raisons()));
+63
Voir le fichier
@@ -0,0 +1,63 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.1) : NoSlow. Vanilla 1.21.1 (LocalPlayer.aiStep, côté client) multiplie l'entrée de déplacement par 0,2 tant
* que le joueur utilise un objet (manger, boire, bander un arc ou une arbalète, bloquer au bouclier, charger un
* trident, longue-vue…). Le serveur ne ralentit rien lui-même : le cheat garde sa vitesse de marche ou de course.
*
* Ordres de grandeur au sol (friction 0,6) : marche 0,216 bloc/tick, course 0,281 ; en usage d'objet ×0,2, soit
* ~0,043 en marchant et ~0,056 si le sprint continue (vanilla ne coupe pas un sprint déjà lancé). Le seuil par défaut
* ({@link GardeConfig#noSlowFacteur} 0,5 × course 0,30 = 0,15 bloc/tick, multiplié par les effets de vitesse) laisse
* donc une marge de plus de ×2,5 au joueur honnête ; le cheat (0,22 à 0,28) le dépasse.
*
* Ne mesure que des paquets d'un tick, au sol serveur, sans déplacement vertical (un saut en mangeant garde l'élan du
* sprint-saut), hors milieu spécial et friction anormale (glace, slime, âmes), après {@link GardeConfig#noSlowGraceTicks}
* ticks d'usage (l'élan de la course décroît en 2 ou 3 ticks) et au moins {@link #SOL_MIN} paquets au sol de suite
* (atterrissage). Infraction après {@link GardeConfig#noSlowTicks} paquets suspects consécutifs. OBSERVE par défaut.
*/
public final class NoSlow {
/** Paquets au sol consécutifs exigés avant de mesurer (élan d'un atterrissage). */
static final int SOL_MIN = 3;
private int serie;
private int solConsecutifs;
private double derniereVitesse;
/**
* @param ticksUsage ticks d'usage d'objet vus par le serveur (-1 inconnu)
* @param facteur tolérance (serveur qui tire : facteurLag)
* @return points d'infraction (0 si rien)
*/
public double enregistrer(EtatMouvement m, int ticksUsage, GardeConfig cfg, double facteur) {
boolean solPlat = m.auSolServeur() && m.ticks() == 1 && Math.abs(m.dy()) < 1e-6;
solConsecutifs = solPlat ? solConsecutifs + 1 : 0;
boolean mesurable = m.ralentiParObjet() && ticksUsage >= 0 && ticksUsage > cfg.noSlowGraceTicks && solPlat
&& solConsecutifs >= SOL_MIN && !m.milieuSpecial() && !m.frictionAnormale();
if (!mesurable || m.dxz() <= seuil(m, cfg) * Math.max(1.0, facteur)) {
serie = 0;
return 0;
}
derniereVitesse = m.dxz();
if (++serie < Math.max(1, cfg.noSlowTicks)) return 0;
serie = 0; // une infraction par série complète
return 2.0;
}
/** Vitesse au sol permise pendant un usage d'objet (blocs/tick), effets de vitesse compris. */
public static double seuil(EtatMouvement m, GardeConfig cfg) {
double effets = 1.0 + 0.2 * Math.max(0, m.amplificateurVitesse());
double f = m.facteurVitesse();
if (!Double.isNaN(f) && !Double.isInfinite(f) && f > effets) effets = f;
return cfg.noSlowFacteur * VitesseHorizontale.COURSE * effets;
}
public double derniereVitesse() {
return derniereVitesse;
}
public void vider() {
serie = 0;
solConsecutifs = 0;
}
}
+75
Voir le fichier
@@ -0,0 +1,75 @@
package com.gastinelgarde.core;
/**
* 0.5 (P3.3) : Nuker (casse de plusieurs blocs par tick). Client vanilla 1.21.1 (MultiPlayerGameMode, vérifié dans les
* sources NeoForge 21.1.234) : une casse au plus par tick client, puis {@code destroyDelay = 5} ticks après un bloc qui
* n'est pas instantané ; même les blocs instantanés (herbe, fleurs) ne partent qu'un par tick au clic maintenu.
*
* Signal : nombre de blocs cassés par le joueur pendant un même tick serveur (BlockEvent.BreakEvent). Des paquets de
* deux ou trois ticks client peuvent arriver groupés dans un tick serveur (gigue réseau) : le plafond
* {@link GardeConfig#nukerBlocsParTickMax} (3) le couvre ; un Nuker en casse en général des dizaines. Points seulement en
* série : {@link GardeConfig#nukerSerieMin} ticks au-delà du plafond parmi les {@link #SERIE} derniers ticks de casse
* (60 s). Un mod serveur qui casse plusieurs blocs « au nom » du joueur (abattage d'arbre, minage de filon) déclenche
* aussi BreakEvent : [À VÉRIFIER] sur la liste des mods du serveur ; OBSERVE par défaut.
*/
public final class Nuker {
public static final int SERIE = 20;
public static final long FENETRE_MS = 60_000;
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
private long tickCourant = Long.MIN_VALUE;
private int casses;
private boolean signale;
private int dernierCompte;
/** Le tick courant a donné une sanction ≥ SETBACK applicable : toutes ses casses excédentaires sont annulées. */
private boolean annulerTick;
/** Un bloc cassé au tick serveur donné. @return points d'infraction */
public double casse(long nowMs, long tick, GardeConfig cfg) {
if (tick != tickCourant) {
tickCourant = tick;
casses = 0;
signale = false;
annulerTick = false;
dernierCompte = serie.ajouter(nowMs, false); // un tick de casse ordinaire
}
casses++;
// Comptabilité seulement : un tick suspect compte une fois dans la série. L'annulation des casses excédentaires
// suivantes du même tick est décidée à part (excedent / annulerTick, revue de sécurité P3).
if (signale || casses <= Math.max(1, cfg.nukerBlocsParTickMax)) return 0;
signale = true; // un tick suspect compté une fois
dernierCompte = serie.ajouter(nowMs, true);
if (dernierCompte < Math.max(1, cfg.nukerSerieMin)) return 0;
return 2.0;
}
/** La casse courante dépasse le plafond du tick (première excédentaire comprise). */
public boolean excedent(long tick, GardeConfig cfg) {
return tick == tickCourant && casses > Math.max(1, cfg.nukerBlocsParTickMax);
}
public void marquerAnnulation() {
annulerTick = true;
}
public boolean annulerTick() {
return annulerTick;
}
public int casses() {
return casses;
}
public int dernierCompte() {
return dernierCompte;
}
public void vider() {
serie.vider();
tickCourant = Long.MIN_VALUE;
casses = 0;
signale = false;
annulerTick = false;
}
}
+56
Voir le fichier
@@ -0,0 +1,56 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.14) : Omnisprint (courir en reculant ou de côté). Vanilla 1.21.1 (LocalPlayer.aiStep, vérifié dans les
* sources NeoForge 21.1.234) coupe le sprint dès que l'entrée vers l'avant est nulle ({@code hasForwardImpulse}) : un
* joueur qui court se déplace au plus à ~45° de son regard (avant + côté). Un déplacement à plus de
* {@link GardeConfig#omnisprintAngleDegres} (100°) du regard en courant n'est possible que par élan (demi-tour de la
* souris, recul) : il disparaît en 2 ou 3 ticks au sol (friction 0,546 par tick).
*
* Signal : {@link GardeConfig#omnisprintTicks} (10) paquets d'un tick de suite, au sol serveur, sprint, au moins
* {@link #DXZ_MIN} bloc par tick, hors milieu spécial et friction anormale (glace), à plus de l'angle du regard.
* Recul, téléportation, véhicule… : exemptions de mouvement. OBSERVE par défaut.
*/
public final class Omnisprint {
static final double DXZ_MIN = 0.15;
private int serie;
private double dernierAngle;
public double enregistrer(EtatMouvement m, FaitsMouvement f, GardeConfig cfg) {
if (Double.isNaN(f.dx) || Double.isNaN(f.dz) || Float.isNaN(f.yaw)) {
serie = 0;
return 0;
}
double angle = angle(f.dx, f.dz, f.yaw);
boolean suspect = m.sprint() && m.auSolServeur() && m.ticks() == 1 && m.dxz() >= DXZ_MIN && !m.milieuSpecial()
&& !m.frictionAnormale() && angle > cfg.omnisprintAngleDegres;
if (!suspect) {
serie = 0;
return 0;
}
dernierAngle = angle;
if (++serie < Math.max(1, cfg.omnisprintTicks)) return 0;
serie = 0;
return 2.0;
}
/** Angle (degrés, 0 à 180) entre le déplacement (dx, dz) et le regard horizontal (yaw Minecraft). */
public static double angle(double dx, double dz, float yaw) {
double r = Math.toRadians(yaw);
double fx = -Math.sin(r), fz = Math.cos(r);
double n = Math.hypot(dx, dz);
if (n < 1e-9) return 0;
double c = (dx * fx + dz * fz) / n;
return Math.toDegrees(Math.acos(Math.max(-1, Math.min(1, c))));
}
public double dernierAngle() {
return dernierAngle;
}
public void vider() {
serie = 0;
}
}
+40 -3
Voir le fichier
@@ -7,11 +7,48 @@ public final class Paliers {
/** Sanction que mériterait ce nombre de points, plafonnée par {@code sanctionMax}. */
public static Sanction palier(double vl, GardeConfig cfg) {
return palier(vl, cfg.seuilAlerte, cfg.seuilSetback, cfg.seuilExpulsion, cfg);
}
/** 0.4.2 : palier avec les seuils propres au contrôle (auto-totem, vélocité) quand ils sont définis (> 0). */
public static Sanction palier(double vl, GardeConfig cfg, Controle c) {
double setback = cfg.seuilSetback;
double expulsion = cfg.seuilExpulsion;
if (c == Controle.AUTO_TOTEM) {
if (cfg.autoTotemSeuilSetback > 0) setback = cfg.autoTotemSeuilSetback;
if (cfg.autoTotemSeuilExpulsion > 0) expulsion = cfg.autoTotemSeuilExpulsion;
} else if (c == Controle.VELOCITE) {
if (cfg.velociteSeuilSetback > 0) setback = cfg.velociteSeuilSetback;
if (cfg.velociteSeuilExpulsion > 0) expulsion = cfg.velociteSeuilExpulsion;
} else if (c == Controle.INVENTAIRE || c == Controle.SCAFFOLD || c == Controle.BLINK || c == Controle.PHASE) {
// 0.6 : seuils propres (sections [inventaire], [scaffold], [blink], [phase]) ; <= 0 = seuil global.
double sb = switch (c) {
case INVENTAIRE -> cfg.inventaireSeuilSetback;
case SCAFFOLD -> cfg.scaffoldSeuilSetback;
case BLINK -> cfg.blinkSeuilSetback;
default -> cfg.phaseSeuilSetback;
};
double ex = switch (c) {
case INVENTAIRE -> cfg.inventaireSeuilExpulsion;
case SCAFFOLD -> cfg.scaffoldSeuilExpulsion;
case BLINK -> cfg.blinkSeuilExpulsion;
default -> cfg.phaseSeuilExpulsion;
};
if (sb > 0) setback = sb;
if (ex > 0) expulsion = ex;
}
setback = Math.min(setback, expulsion);
double alerte = Math.min(cfg.seuilAlerte, setback);
return palier(vl, alerte, setback, expulsion, cfg);
}
private static Sanction palier(double vl, double seuilAlerte, double seuilSetback, double seuilExpulsion,
GardeConfig cfg) {
Sanction s;
if (vl <= 0) s = Sanction.AUCUNE;
else if (vl < cfg.seuilAlerte) s = Sanction.JOURNAL;
else if (vl < cfg.seuilSetback) s = Sanction.ALERTE;
else if (vl < cfg.seuilExpulsion) s = Sanction.SETBACK;
else if (vl < seuilAlerte) s = Sanction.JOURNAL;
else if (vl < seuilSetback) s = Sanction.ALERTE;
else if (vl < seuilExpulsion) s = Sanction.SETBACK;
else s = Sanction.EXPULSION;
return Sanction.min(s, cfg.sanctionMax);
}
+36
Voir le fichier
@@ -0,0 +1,36 @@
package com.gastinelgarde.core;
/**
* 0.6 (P3.5) : Phase / NoClip / VClip. Vanilla (handleMovePlayer, sources NeoForge 21.1.234) refuse déjà d'entrer dans
* un bloc : le déplacement est rejoué avec collisions, et la position est refusée (« moved wrongly », ou
* {@code isPlayerCollidingWithAnythingNew}) avant d'être acceptée. Ce contrôle ne sanctionne donc pas un passage qui
* aurait réussi : il <b>compte les tentatives</b>, c'est-à-dire les positions refusées par vanilla dont la boîte
* déclarée chevauche un bloc solide (ou une entité solide). Un vrai joueur en provoque quelques-unes (porte qui se
* ferme, piston, bloc posé par un autre joueur pendant un lag) ; un client de phase en envoie en continu.
*
* Il faut {@link GardeConfig#phaseSerieMin} (5) refus dans un bloc en 10 s ; ensuite chaque refus compte. OBSERVE par
* défaut : le seuil n'a jamais été comparé à de vrais joueurs (Create, Sable et les ascenseurs peuvent en provoquer).
*/
public final class Phase {
public static final long FENETRE_MS = 10_000;
private final SerieFenetre serie = new SerieFenetre(32, FENETRE_MS);
private int compte;
/** Paquet de mouvement refusé par vanilla ; {@code dansBloc} : la boîte déclarée chevauche un bloc solide. */
public double refus(long nowMs, boolean dansBloc, GardeConfig cfg) {
if (!dansBloc) return 0;
compte = serie.ajouter(nowMs, true);
return compte >= Math.max(1, cfg.phaseSerieMin) ? 1.0 : 0;
}
public int compte() {
return compte;
}
public void vider() {
serie.vider();
compte = 0;
}
}
+175
Voir le fichier
@@ -0,0 +1,175 @@
package com.gastinelgarde.core;
/**
* Contrôle « elytres » (0.4.0) : le plané est exempté de vitesse, de vol et de no-fall (Exemptions, famille
* mouvement). Le « Elytra Hack » de CheatUtils (méthode VanillaFly) donne au plané l'accélération verticale et
* horizontale du vol créatif : on monte à vitesse constante ou on reste sur place. Le vanilla ne le permet pas :
* <ul>
* <li>monter coûte de la vitesse horizontale (l'énergie vient de la piqué) : une montée de plus de
* {@link GardeConfig#elytresMonteeTicks} ticks sans perte de vitesse est impossible sans fusée ;</li>
* <li>rester presque immobile sans chute ({@link GardeConfig#elytresStationnaireTicks} ticks) est impossible :
* à faible vitesse la portance est nulle et le joueur tombe.</li>
* </ul>
* Aucune des deux règles ne s'applique après une fusée (propulsion récente), dans un milieu spécial (courant d'air
* Create, colonne à bulles, eau…), ni quand une autre exemption est active (le moteur n'appelle ce contrôle que si
* « elytres » est la seule raison d'exemption). Les valeurs sont à confirmer en jeu : OBSERVE par défaut.
*
* <p>Pourquoi l'option C7 ({@code elytresExemptionStricte}) ne suffit pas : elle retire seulement l'exemption quand
* le plané démarre sans ticks en l'air côté serveur (onGround falsifié). Un tricheur qui saute puis déploie ses
* élytres normalement reste exempté de tout, et C7 ne regarde jamais ce que le plané fait ensuite.
*/
public final class PlaneElytres {
/** Montée franche (blocs par tick) ; en dessous, c'est du plané à plat. */
public static final double MONTEE_MIN = 0.05;
/** Une montée qui garde au moins cette part de la vitesse horizontale du début est suspecte. */
public static final double VITESSE_GARDEE = 0.9;
/** Vitesse horizontale (blocs par tick) en dessous de laquelle le plané ne porte plus. */
public static final double VITESSE_STATIONNAIRE = 0.15;
/** Chute (blocs par tick) en dessous de laquelle on ne tombe pas vraiment. */
public static final double CHUTE_MIN = -0.04;
/** Paquets au-delà de ce nombre de ticks : pas de mesure fiable (retard réseau). */
public static final int TICKS_MAX = 3;
/** Ticks de grâce après lesquels on exige que la fusée ait fait gagner de la vitesse. */
public static final int GAIN_TICKS = 10;
/** Gain de vitesse horizontale (blocs par tick) attendu d'une fusée réelle. */
public static final double GAIN_MIN = 0.05;
/** Au-dessus de cette vitesse (blocs par tick) la fusée n'a plus de gain possible : grâce maintenue. */
public static final double VITESSE_FUSEE = 1.6;
private int graceTicks;
private int fenetreGrace;
private double vitesseGrace;
/** Dernière vitesse mesurée HORS grâce de fusée ; invalide tant que {@link #vitesseConnue} est faux. */
private double derniereVitesse;
private boolean vitesseConnue;
/** Une fenêtre de grâce a échoué au test de gain : pas de nouvelle grâce avant {@link #PAUSE_APRES_REFUS} ticks hors grâce. */
private boolean graceRefusee;
private int horsGraceTicks;
/** Ticks sans fusée exigés après une grâce refusée (≈ une durée de vie de fusée) avant d'en accepter une autre. */
public static final int PAUSE_APRES_REFUS = 40;
private final double[] fenetre = new double[GAIN_TICKS];
/** 0.4.1 : vitesse 3D (horizontale et verticale) des memes ticks : une fusee pousse dans le sens du regard. */
private final double[] fenetre3d = new double[GAIN_TICKS];
private int monteeTicks;
private double vitesseDebut;
private int stationnaireTicks;
/**
* @param m déplacement accepté
* @param propulsion une fusée (ou autre poussée connue du serveur) est récente
* @return points d'infraction (0 si rien)
*/
public double enregistrer(EtatMouvement m, boolean propulsion, GardeConfig cfg) {
int n = m.ticks();
if (m.milieuSpecial() || m.auSolServeur()) {
vider();
return 0;
}
if (propulsion) {
// Grâce de fusée : les compteurs sont SUSPENDUS (ni remis à zéro, ni avancés), pas effacés : tirer une fusée
// ne blanchit pas une montée ou un plané immobile déjà en cours. Grâce révoquée tôt si la fusée ne
// pousse pas réellement (vitesse horizontale sans gain au bout de GAIN_TICKS ticks).
if (n >= 1 && n <= TICKS_MAX) {
double vh = m.dxz() / n;
if (graceRefusee) return mesurer(m, n, cfg); // grâce déjà refusée : pas de nouvelle fenêtre tout de suite
if (graceTicks == 0) {
// référence = dernière vitesse mesurée hors grâce ; inconnue (atterrissage, milieu spécial,
// première mesure) : la vitesse courante, donc le gain exigé part de ce qu'on voit (pessimiste)
vitesseGrace = vitesseConnue ? derniereVitesse : vh;
fenetreGrace = 0;
}
graceTicks += n;
fenetre3d[fenetreGrace % GAIN_TICKS] = Math.hypot(m.dxz(), m.dy()) / n;
fenetre[fenetreGrace++ % GAIN_TICKS] = vh;
if (!graceTenue()) {
graceRefusee = true;
horsGraceTicks = 0;
// la fusée ne pousse pas (ou un pic isolé a masqué une vitesse plate) : contrôle comme sans fusée
return mesurer(m, n, cfg);
}
return 0;
}
return 0;
} else {
graceTicks = 0;
fenetreGrace = 0;
if (graceRefusee && n >= 1 && (horsGraceTicks += n) >= PAUSE_APRES_REFUS) graceRefusee = false;
if (n >= 1 && n <= TICKS_MAX) {
derniereVitesse = m.dxz() / n; // seulement hors grâce
vitesseConnue = true;
}
}
return mesurer(m, n, cfg);
}
/**
* Nouvelle fusée tirée en plané. Ne remet RIEN à zéro : des fusées enchaînées cumulent leurs ticks de grâce dans la
* même fenêtre (sinon un tricheur ne sortirait jamais de la grâce et le test de gain ne serait jamais évalué) et la
* référence de vitesse reste celle d'avant la première fusée. La fenêtre ne se ferme que quand le drapeau de
* propulsion tombe (paquet hors grâce). Gardée pour le journal d'appel et les tests.
*/
public void nouvelleFusee() {
// volontairement vide
}
/**
* La grâce tient tant que la fusée pousse réellement : avant {@link #GAIN_TICKS} ticks, oui ; ensuite la MÉDIANE
* des {@link #GAIN_TICKS} derniers ticks (insensible à un pic isolé) doit dépasser d'au moins {@link #GAIN_MIN}
* la vitesse d'avant la fusée, ou tous ces ticks doivent rester proches de {@link #VITESSE_FUSEE} (vitesse où la
* fusée ne peut plus faire gagner).
*/
private boolean graceTenue() {
if (graceTicks < GAIN_TICKS || fenetreGrace < GAIN_TICKS) return true;
double[] v = fenetre.clone();
java.util.Arrays.sort(v);
double mediane = (v[GAIN_TICKS / 2 - 1] + v[GAIN_TICKS / 2]) / 2.0;
double min = v[0];
if (mediane >= vitesseGrace + GAIN_MIN || min >= VITESSE_FUSEE * 0.9) return true;
// 0.4.1 (faux positif totoche10, dxz 1,3-1,5 dy 0,66-1,04) : en montee avec fusee, la poussee (~1,5-1,7 bloc/tick)
// part dans le sens du regard ; la vitesse HORIZONTALE peut rester sous la reference sans que la fusee soit fausse.
double min3d = Double.MAX_VALUE;
for (double x : fenetre3d) min3d = Math.min(min3d, x);
return min3d >= VITESSE_FUSEE * 0.9;
}
private double mesurer(EtatMouvement m, int n, GardeConfig cfg) {
if (n < 1 || n > TICKS_MAX) return 0; // neutre : ni remise à zéro ni ajout
double vh = m.dxz() / n;
double vy = m.dy() / n;
double points = 0;
if (vh < VITESSE_STATIONNAIRE && vy > CHUTE_MIN) stationnaireTicks += n;
else stationnaireTicks = 0;
if (cfg.elytresStationnaireTicks > 0 && stationnaireTicks > cfg.elytresStationnaireTicks) {
points = 1.5;
stationnaireTicks = 0; // 0.4.1 : au plus 1,5 point par periode, pas 1,5 par paquet (+30 VL/s en 0.4.0)
}
if (vy > MONTEE_MIN) {
if (monteeTicks == 0) vitesseDebut = vh;
monteeTicks += n;
if (cfg.elytresMonteeTicks > 0 && monteeTicks > cfg.elytresMonteeTicks
&& vh >= vitesseDebut * VITESSE_GARDEE) {
points = Math.max(points, 1.5);
monteeTicks = 0; // 0.4.1 : idem, la periode suivante repart de la vitesse courante
}
} else if (vy < 0) {
monteeTicks = 0;
}
return points;
}
public void vider() {
graceTicks = 0;
fenetreGrace = 0;
derniereVitesse = 0;
vitesseConnue = false;
graceRefusee = false;
horsGraceTicks = 0;
monteeTicks = 0;
vitesseDebut = 0;
stationnaireTicks = 0;
}
}
+1 -1
Voir le fichier
@@ -98,7 +98,7 @@ public final class PorteeHitbox {
*/
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
if (e.riptide()) return "riptide";
if (e.elytres()) return "elytres";
if (e.elytres() && !cfg.elytresExemptionStricte) return "elytres"; // C7 : mesuré avec l'option
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
+131
Voir le fichier
@@ -0,0 +1,131 @@
package com.gastinelgarde.core;
import java.util.Locale;
/**
* 0.6 (P3.2, partie « Scaffold horizontal ») : pont posé sous les pieds pendant la marche. Le client vanilla ne pose un
* bloc que là où vise le réticule : le point cliqué est sur le rayon du regard, au moment du clic. Le clic part entre
* la rotation du dernier paquet de mouvement et celle du suivant (la souris bouge à chaque image). Deux anomalies :
* <ul>
* <li><b>hors-regard</b> : le point cliqué est à plus de {@link GardeConfig#scaffoldAngleMaxDeg} (50°) de toutes les
* rotations entre ces deux paquets (Scaffold sans rotation, pose « derrière soi ») ;</li>
* <li><b>snap</b> (Scaffold à rotation silencieuse) : la rotation fait un aller de plus de
* {@link GardeConfig#scaffoldSnapDeg} (70°) juste avant la pose, puis un retour d'autant juste après, vers le regard
* d'avant. Un pont humain (ninja, god-bridge, pont en reculant) garde le regard à peu près fixe.</li>
* </ul>
* Il faut {@link GardeConfig#scaffoldSerieMin} (4) poses anormales parmi les 10 dernières poses de pont en 30 s ; ensuite
* chaque pose anormale compte et, pendant 2 s, les poses de pont suivantes sont annulables en ENFORCE (l'anomalie
* n'est connue qu'au paquet de mouvement d'après, la pose a déjà eu lieu). Les clics « derrière soi » de vrais
* joueurs qui retournent la tête très vite (180° en une image) sont possibles : OBSERVE par défaut.
*/
public final class Scaffold {
public static final int SERIE = 10;
public static final long FENETRE_MS = 30_000;
public static final int ANNULATION_TICKS = 40;
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
private boolean attente;
private float dirYaw, dirPitch, yawAvant, pitchAvant, yawPose, pitchPose;
private long suspectJusquaTick = Long.MIN_VALUE;
private int compte;
private String detail = "";
/**
* Le bloc posé fait-il partie d'un pont sous les pieds ? Bloc juste sous le niveau des pieds, à côté de la colonne du
* joueur (pas dedans : c'est le tower), joueur qui ne monte ni ne descend et qui avance.
*/
public static boolean estPont(int bx, int by, int bz, double px, double py, double pz, double dy, double vitesseH) {
boolean sousPieds = py >= by + 1 - 0.01 && py < by + 1.6;
boolean colonne = (int) Math.floor(px) == bx && (int) Math.floor(pz) == bz;
double hx = bx + 0.5 - px, hz = bz + 0.5 - pz;
boolean proche = hx * hx + hz * hz <= 1.8 * 1.8;
return sousPieds && !colonne && proche && Math.abs(dy) < 0.1 && vitesseH >= 0.03;
}
/**
* Pose de pont : retenue jusqu'au paquet de mouvement suivant.
*
* @param dirYaw, dirPitch direction œil → point cliqué
* @param yawAvant, pitchAvant rotation du paquet d'avant le dernier
* @param yawPose, pitchPose rotation du dernier paquet (au moment de la pose)
*/
public void pose(float dirYaw, float dirPitch, float yawAvant, float pitchAvant, float yawPose, float pitchPose) {
this.attente = true;
this.dirYaw = dirYaw;
this.dirPitch = dirPitch;
this.yawAvant = yawAvant;
this.pitchAvant = pitchAvant;
this.yawPose = yawPose;
this.pitchPose = pitchPose;
}
/** Paquet de mouvement accepté après une pose de pont : juge la pose. */
public double regard(long tick, long nowMs, float yaw, float pitch, GardeConfig cfg) {
if (!attente) return 0;
attente = false;
double horsRegard = ecartArc(yawPose, pitchPose, yaw, pitch, dirYaw, dirPitch);
double aller = angle(yawAvant, pitchAvant, yawPose, pitchPose);
double retour = angle(yawPose, pitchPose, yaw, pitch);
double bilan = angle(yawAvant, pitchAvant, yaw, pitch);
boolean hors = horsRegard > cfg.scaffoldAngleMaxDeg;
boolean snap = aller >= cfg.scaffoldSnapDeg && retour >= cfg.scaffoldSnapDeg && bilan <= cfg.scaffoldSnapDeg / 2;
boolean anomalie = hors || snap;
compte = serie.ajouter(nowMs, anomalie);
detail = String.format(Locale.ROOT,
"pont : %s ecart au regard %.0f deg (max %.0f), aller %.0f / retour %.0f deg (snap %.0f), %d/%d anomalies",
hors ? "hors-regard," : snap ? "snap," : "", horsRegard, cfg.scaffoldAngleMaxDeg, aller, retour,
cfg.scaffoldSnapDeg, compte, SERIE);
if (anomalie && compte >= Math.max(1, cfg.scaffoldSerieMin)) {
suspectJusquaTick = tick + ANNULATION_TICKS;
return 1.0;
}
return 0;
}
/** Pendant la période suspecte, une pose de pont est annulable en ENFORCE. */
public boolean suspect(long tick) {
return tick <= suspectJusquaTick;
}
public String detail() {
return detail;
}
public void vider() {
attente = false;
serie.vider();
suspectJusquaTick = Long.MIN_VALUE;
}
/** Plus petit écart (degrés) entre la direction et les rotations sur l'arc le plus court de r0 à r1. */
static double ecartArc(float y0, float p0, float y1, float p1, float dy, float dp) {
double dyaw = ((y1 - y0) % 360 + 540) % 360 - 180;
double min = Double.MAX_VALUE;
for (int i = 0; i <= 8; i++) {
double t = i / 8.0;
min = Math.min(min, angle((float) (y0 + dyaw * t), (float) (p0 + (p1 - p0) * t), dy, dp));
}
return min;
}
/** Angle (degrés) entre deux regards (yaw, pitch Minecraft). */
static double angle(float y0, float p0, float y1, float p1) {
double[] a = vecteur(y0, p0), b = vecteur(y1, p1);
double c = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
return Math.toDegrees(Math.acos(Math.max(-1, Math.min(1, c))));
}
static double[] vecteur(float yaw, float pitch) {
double y = Math.toRadians(yaw), p = Math.toRadians(pitch);
return new double[] {-Math.sin(y) * Math.cos(p), -Math.sin(p), Math.cos(y) * Math.cos(p)};
}
/** Rotation Minecraft (yaw, pitch) d'une direction. */
public static float[] rotation(double dx, double dy, double dz) {
double h = Math.sqrt(dx * dx + dz * dz);
float yaw = (float) Math.toDegrees(Math.atan2(-dx, dz));
float pitch = (float) Math.toDegrees(Math.atan2(-dy, h));
return new float[] {yaw, pitch};
}
}
+42
Voir le fichier
@@ -0,0 +1,42 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2) : série générique « k suspects parmi les n dernières mesures, dans une fenêtre de temps », comme
* {@link SerieCoups} mais sans réglage lu dans la configuration. Tampon de taille fixe, aucune allocation.
*/
public final class SerieFenetre {
private final int n;
private final long fenetreMs;
private final long[] instants;
private final boolean[] suspects;
private int taille;
private int tete;
public SerieFenetre(int n, long fenetreMs) {
this.n = Math.max(1, n);
this.fenetreMs = fenetreMs;
this.instants = new long[this.n];
this.suspects = new boolean[this.n];
}
/** Ajoute une mesure ; renvoie le nombre de suspectes parmi les n dernières encore dans la fenêtre. */
public int ajouter(long nowMs, boolean suspect) {
instants[tete] = nowMs;
suspects[tete] = suspect;
tete = (tete + 1) % n;
if (taille < n) taille++;
int compte = 0;
for (int k = 0; k < taille; k++) {
int i = ((tete - 1 - k) % n + n) % n;
if (nowMs - instants[i] > fenetreMs || instants[i] > nowMs) break;
if (suspects[i]) compte++;
}
return compte;
}
public void vider() {
taille = 0;
tete = 0;
}
}
+52
Voir le fichier
@@ -0,0 +1,52 @@
package com.gastinelgarde.core;
/**
* 0.5 (P1.9) : Step / HighStep. Un joueur au sol (vu par le serveur) au paquet précédent et à celui-ci, qui a gagné
* en un seul tick plus que la hauteur de marche permise.
*
* Valeurs vanilla 1.21.1 (vérifiées dans les sources décompilées de NeoForge 21.1.234, Attributes.java et
* LivingEntity.getJumpPower) : attribut {@code generic.step_height} 0,6 par défaut ; saut = attribut
* {@code generic.jump_strength} (0,42) × facteur de saut du bloc + 0,1 par niveau de Saut amélioré. Un saut ne
* donne jamais plus que sa puissance en un tick : la hauteur permise est le maximum des deux (fournie par
* l'adaptateur), plus une marge. Escaliers, dalles, chemins, lits (≤ 0,6) ne comptent donc jamais.
*
* Ce que le contrôle ne voit pas (volontairement) : plusieurs ticks entre deux paquets (le gain est réparti),
* milieux spéciaux (échelle, eau…), hauteur permise inconnue (piston en mouvement à proximité : l'adaptateur passe
* NaN). OBSERVE par défaut.
*/
public final class Step {
private boolean connu;
private boolean solAvant;
private double dernierGain;
/**
* @param hauteurPermise max(step_height, puissance de saut) du joueur ; NaN = inconnue, pas de mesure
* @return points d'infraction (0 si rien)
*/
public double enregistrer(EtatMouvement m, double hauteurPermise, GardeConfig cfg) {
boolean avant = connu && solAvant;
connu = true;
solAvant = m.auSolServeur();
if (!avant || !m.auSolServeur() || m.ticks() != 1 || m.milieuSpecial() || Double.isNaN(hauteurPermise)) return 0;
double seuil = seuil(hauteurPermise, cfg);
if (m.dy() <= seuil) return 0;
dernierGain = m.dy();
// 2 points par marche anormale, jusqu'à 5 pour un gain d'un bloc et plus au-delà du seuil.
return 2.0 + Math.min(3.0, (m.dy() - seuil) * 3.0);
}
public static double seuil(double hauteurPermise, GardeConfig cfg) {
return Math.max(cfg.stepHauteurMax, hauteurPermise) + Math.max(0, cfg.stepMargeBlocs);
}
public double dernierGain() {
return dernierGain;
}
/** Période exemptée, téléportation : le paquet suivant sert de référence. */
public void vider() {
connu = false;
solAvant = false;
}
}
+84
Voir le fichier
@@ -33,6 +33,9 @@ public final class Suivi {
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
/** 0.6.1 (revue M1) : instant (ms) du dernier setback appliqué. */
long dernierSetbackMs = Long.MIN_VALUE;
void noterSetback(long nowMs) {
setbacks.addLast(nowMs);
while (setbacks.size() > 32) setbacks.removeFirst();
@@ -53,8 +56,89 @@ public final class Suivi {
private final Map<Controle, Long> derniereAlerte = new EnumMap<>(Controle.class);
/** Score de suspicion (0.4.0). */
public final Suspicion suspicion;
/** 0.4.0 : plané, recul, totem. */
public final PlaneElytres plane = new PlaneElytres();
public final Velocite velocite = new Velocite();
public final AutoTotem totem = new AutoTotem();
/** 0.5 (P1) : step. */
public final Step step = new Step();
/** 0.5 (P1.10) : criticals. */
public final Criticals criticals = new Criticals();
/** 0.5 (P1.8) : anti-faim. */
public final AntiFaim antiFaim = new AntiFaim();
/** 0.5 (P2.1) : no-slow. */
public final NoSlow noSlow = new NoSlow();
/** 0.5 (P2.3) : fast-break. */
public final FastBreak fastBreak = new FastBreak();
/** 0.5 (P2.4) : fast-place. */
public final FastPlace fastPlace = new FastPlace();
/** 0.5 (P2.5) : interaction-bloc. */
public final InteractionBloc interactionBloc = new InteractionBloc();
/** 0.5 (P2.7) : auto-totem régulier. */
public final TotemRegulier totemRegulier = new TotemRegulier();
/** 0.5 (P2.11) : jesus. */
public final Jesus jesus = new Jesus();
/** 0.5 (P2.14) : omnisprint. */
public final Omnisprint omnisprint = new Omnisprint();
/** 0.5 (P2.10) : x-ray statistique. */
public final XrayStats xray = new XrayStats();
/** 0.6.1 (revue M3) : blocs récemment changés (casse, pose, cible d'un clic droit) près du joueur. */
public final PositionsRecentes changementsBloc = new PositionsRecentes();
/** 0.6.1 (revue M2) : blocs visés par un paquet de casse du joueur (START/STOP/ABORT). */
public final PositionsRecentes paquetsCasse = new PositionsRecentes();
/** 0.6.1 : petite mémoire circulaire (32 entrées) de positions de bloc ({@code BlockPos.asLong}) datées. */
public static final class PositionsRecentes {
private static final int TAILLE = 32;
private final long[] cles = new long[TAILLE];
private final long[] instants = new long[TAILLE];
private int suivant;
private int remplies;
public void noter(long cle, long nowMs) {
cles[suivant] = cle;
instants[suivant] = nowMs;
suivant = (suivant + 1) % TAILLE;
if (remplies < TAILLE) remplies++;
}
/** Vrai si {@code cle} a été notée dans les {@code fenetreMs} qui précèdent {@code nowMs} (bornes comprises). */
public boolean contient(long cle, long nowMs, long fenetreMs) {
for (int i = 0; i < remplies; i++) {
if (cles[i] == cle && nowMs >= instants[i] && nowMs - instants[i] <= fenetreMs) return true;
}
return false;
}
}
/** 0.5 (P3.3) : nuker. */
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.6 : inventaire, scaffold horizontal, blink, phase (oubliés à la déconnexion avec le Suivi). */
public final Inventaire inventaire = new Inventaire();
public final Scaffold scaffold = new Scaffold();
public final Blink blink = new Blink();
public final Phase phase = new Phase();
/** 0.5 (P3.7) : complétion de commande. */
public final Completion completion = new Completion();
public boolean completionExces;
/** 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. */
public final ActionsBloc actionsBloc = new ActionsBloc();
public Suivi(double decroissanceParSeconde) {
this(decroissanceParSeconde, new GardeConfig());
}
public Suivi(double decroissanceParSeconde, GardeConfig cfg) {
this.vl = new VlCompteur(decroissanceParSeconde);
this.suspicion = new Suspicion(cfg);
}
public void memoriserPosition(double x, double y, double z, float yaw, float pitch, String dimension) {
+128
Voir le fichier
@@ -0,0 +1,128 @@
package com.gastinelgarde.core;
import java.util.EnumMap;
import java.util.Map;
/**
* Score de suspicion d'un joueur, de 0 à 100 (0.4.0). Information pour les humains : ne sanctionne jamais.
*
* <p>Par contrôle, on garde le plus haut rapport {@code VL / seuilExpulsion} vu (borné à 1), qui décroît avec une
* demi-vie ({@link GardeConfig#suspicionDemiVieMinutes}). Le score est la somme de ces rapports multipliés par le
* plafond de fiabilité du contrôle (50 / 30 / 15), plafonnée à 100. Les contrôles en OBSERVE comptent. Le VL
* lui-même retombe vite (0,5 point/s) et un setback le remet à zéro : on garde donc un pic à part.
*
* <p>Diversité : au moins {@link GardeConfig#suspicionDiversiteControles} contrôles distincts au palier SETBACK
* (mérité, quel que soit le mode) dans la fenêtre = au moins « suspect fort » tant que la fenêtre dure.
*
* <p>Le temps est fourni par l'appelant (ms, horloge unique par moteur), jamais lu ici.
*/
public final class Suspicion {
public enum Niveau { NORMAL, A_SURVEILLER, SUSPECT, SUSPECT_FORT }
private final GardeConfig cfg;
private final Map<Controle, Double> pics = new EnumMap<>(Controle.class);
private final Map<Controle, Long> dernierSetback = new EnumMap<>(Controle.class);
private long dernierMs = Long.MIN_VALUE;
private Niveau notifie = Niveau.NORMAL;
private Niveau enAttente;
public Suspicion(GardeConfig cfg) {
this.cfg = cfg;
}
/** Plafond de contribution du contrôle selon sa fiabilité. */
public static double plafond(Controle c, GardeConfig cfg) {
return switch (c.fiabilite()) {
case 0 -> cfg.suspicionPlafondFiable;
case 1 -> cfg.suspicionPlafondMoyen;
default -> cfg.suspicionPlafondFaible;
};
}
public static Niveau niveau(double score, GardeConfig cfg) {
if (score >= cfg.suspicionSeuilFort) return Niveau.SUSPECT_FORT;
if (score >= cfg.suspicionSeuilSuspect) return Niveau.SUSPECT;
if (score >= cfg.suspicionSeuilSurveiller) return Niveau.A_SURVEILLER;
return Niveau.NORMAL;
}
private double facteur(long nowMs) {
if (dernierMs == Long.MIN_VALUE || nowMs <= dernierMs) return 1.0;
double demiVieMs = Math.max(1, cfg.suspicionDemiVieMinutes * 60_000.0);
return Math.pow(0.5, (nowMs - dernierMs) / demiVieMs);
}
private void avancer(long nowMs) {
double f = facteur(nowMs);
if (f != 1.0) pics.replaceAll((k, v) -> v * f);
if (dernierMs == Long.MIN_VALUE || nowMs > dernierMs) dernierMs = nowMs;
}
/**
* Un verdict est tombé.
*
* @param vl VL du contrôle après ajout
* @param palierSetbackOuPlus le palier mérité est SETBACK ou EXPULSION (mode ignoré)
*/
public void noter(Controle c, double vl, boolean palierSetbackOuPlus, long nowMs) {
if (!cfg.suspicionActive) return;
avancer(nowMs);
// réarmement avec hystérésis (80 % du premier seuil) : un score qui oscille autour de 25 ne re-notifie pas
if (score(nowMs) < cfg.suspicionSeuilSurveiller * 0.8) notifie = Niveau.NORMAL;
double ratio = Math.max(0, Math.min(1, vl / Math.max(0.1, cfg.seuilExpulsion)));
pics.merge(c, ratio, Math::max);
if (palierSetbackOuPlus) dernierSetback.put(c, nowMs);
Niveau n = niveau(score(nowMs), cfg);
if (n.ordinal() > notifie.ordinal()) {
notifie = n;
enAttente = n;
}
}
/** Nombre de contrôles distincts au palier SETBACK ou plus dans la fenêtre de diversité. */
public int controlesDivers(long nowMs) {
long fenetre = (long) (cfg.suspicionDiversiteFenetreMinutes * 60_000.0);
int n = 0;
for (long t : dernierSetback.values()) if (nowMs - t <= fenetre) n++;
return n;
}
/** Score courant (0 à 100), diversité comprise. */
public double score(long nowMs) {
double somme = 0;
for (Controle c : pics.keySet()) somme += contribution(c, nowMs);
double s = Math.min(100.0, somme);
if (cfg.suspicionDiversiteControles > 0 && controlesDivers(nowMs) >= cfg.suspicionDiversiteControles) {
s = Math.max(s, cfg.suspicionSeuilFort);
}
return s;
}
public Niveau niveau(long nowMs) {
return niveau(score(nowMs), cfg);
}
/** Contribution actuelle d'un contrôle (points de score). */
public double contribution(Controle c, long nowMs) {
Double p = pics.get(c);
return p == null ? 0 : p * facteur(nowMs) * plafond(c, cfg);
}
/** Nouveau niveau franchi vers le haut depuis le dernier appel (une seule fois), ou null. */
public Niveau prendreTransition() {
Niveau n = enAttente;
enAttente = null;
return n;
}
/** Texte « vol:40 vitesse:12 » des contributions non nulles, pour le journal. */
public String resume(long nowMs) {
StringBuilder sb = new StringBuilder();
for (Controle c : Controle.values()) {
double v = contribution(c, nowMs);
if (v >= 0.5) sb.append(sb.length() == 0 ? "" : " ").append(c.id()).append(':').append(Math.round(v));
}
return sb.toString();
}
}
+3 -3
Voir le fichier
@@ -19,9 +19,9 @@ public final class TimerPaquets {
/**
* C15 (16/10) : solde de paquets (reçus - ticks écoulés), option {@link GardeConfig#timerSoldeMax} (0 = désactivé).
* Un timer à 1,09 (21,8 paquets/s) restait sous le seuil de 22 paquets/s ; son solde, lui, grandit sans fin. Le
* crédit accumulé pendant un lag (paquets en retard, puis rafale de rattrapage) est borné à {@link #CREDIT_MAX}.
* crédit accumulé pendant un lag (paquets en retard, puis rafale de rattrapage) est borné à
* {@link GardeConfig#timerDetteMax} (0.5, P1.12 : réglable ; 40 en dur avant).
*/
static final double CREDIT_MAX = 40;
private double solde;
private long dernierMs = Long.MIN_VALUE;
@@ -33,7 +33,7 @@ public final class TimerPaquets {
return 0;
}
solde += 1.0 - Math.max(0, nowMs - dernierMs) / (double) TRANCHE_MS;
solde = Math.max(-CREDIT_MAX, solde);
solde = Math.max(-Math.max(0, cfg.timerDetteMax), solde);
dernierMs = Math.max(dernierMs, nowMs);
double max = cfg.timerSoldeMax * facteur;
if (solde <= max) return 0;
+61
Voir le fichier
@@ -0,0 +1,61 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.7) : auto-totem, contre-contournement. Les modules AutoTotem récents attendent un délai fixe (souvent 200 à
* 300 ms, parfois avec une petite variation) pour passer au-dessus du seuil minimal de {@link AutoTotem}. Un humain qui
* remet un totem (inventaire ou touche d'échange de main) varie de plusieurs centaines de millisecondes d'un
* éclatement à l'autre. On regarde donc la distribution des délais mesurés : sur les
* {@link GardeConfig#autoTotemEchantillons} derniers (5), tous sous {@link GardeConfig#autoTotemRegulierMaxMs} (300 ms)
* et un écart type sous {@link GardeConfig#autoTotemEcartTypeMinMs} (30 ms) : machine.
*
* Les délais sont quantifiés au tick (50 ms) : un écart type sous 30 ms veut dire presque toujours le même tick.
* Contrôle séparé d'auto-totem (en ENFORCE en production) : nouveau, donc OBSERVE par défaut.
*/
public final class TotemRegulier {
public static final int TAILLE_MAX = 16;
private final long[] delais = new long[TAILLE_MAX];
private int taille;
private int tete;
private double dernierEcartType = Double.NaN;
private double derniereMoyenne = Double.NaN;
/** Un délai éclatement → totem en main vient d'être mesuré (ms). @return points d'infraction */
public double delai(long delaiMs, GardeConfig cfg) {
delais[tete] = delaiMs;
tete = (tete + 1) % TAILLE_MAX;
if (taille < TAILLE_MAX) taille++;
int n = Math.max(3, Math.min(TAILLE_MAX, cfg.autoTotemEchantillons));
if (taille < n) return 0;
double somme = 0;
long max = Long.MIN_VALUE;
for (int k = 0; k < n; k++) {
long d = delais[((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX];
somme += d;
max = Math.max(max, d);
}
double moyenne = somme / n;
double variance = 0;
for (int k = 0; k < n; k++) {
long d = delais[((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX];
variance += (d - moyenne) * (d - moyenne);
}
dernierEcartType = Math.sqrt(variance / n);
derniereMoyenne = moyenne;
return max < cfg.autoTotemRegulierMaxMs && dernierEcartType < cfg.autoTotemEcartTypeMinMs ? 2.0 : 0;
}
public double dernierEcartType() {
return dernierEcartType;
}
public double derniereMoyenne() {
return derniereMoyenne;
}
public void vider() {
taille = 0;
tete = 0;
}
}
+66
Voir le fichier
@@ -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 &gt; 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;
}
}
+107
Voir le fichier
@@ -0,0 +1,107 @@
package com.gastinelgarde.core;
import java.util.ArrayDeque;
/**
* Contrôle « velocite » (0.4.0) : anti-recul (Anti Knockback) et anti-poussée (Anti Push) de CheatUtils annulent côté
* client la vitesse que le serveur vient de donner. Le serveur sait quand il applique un recul (LivingKnockBackEvent,
* explosions) et sa force ; il voit ensuite les paquets de mouvement. Vanilla : la vitesse est posée d'un coup
* (0,4 de base, plus avec un coup en courant ou Recul) et le joueur recule d'environ 4,5 x la force en 6 ticks. Un
* joueur honnête peut contrer en marchant (au plus ~0,22 bloc par tick) ou être arrêté par un mur : un recul
* absent n'est donc compté que s'il manque presque tout ({@link GardeConfig#velociteRapportMin}) et seulement
* en série ({@link GardeConfig#velociteSerieMin} sur les {@link #HISTORIQUE} derniers reculs de 2 minutes).
*
* <p>Un second recul pendant la fenêtre, un changement de milieu (eau, véhicule, vol…) ou toute exemption annule la
* mesure en cours. Ni sanction ni VL à partir d'un recul isolé.
*/
public final class Velocite {
/** Recul vanilla : distance parcourue en 6 ticks / force (frottement 0,91 en l'air : somme des 6 termes ~ 4,8). */
public static final double DISTANCE_PAR_FORCE = 4.5;
public static final int HISTORIQUE = 6;
public static final long VALIDITE_MS = 120_000;
/** Ticks où le sens du recul est bloqué au-delà desquels la mesure est abandonnée. */
public static final int TICKS_BLOQUES_ABANDON = 2;
private boolean actif;
private int ticksBloques;
private boolean ambigu;
private long debutMs;
private double dirX, dirZ, force, parcouru;
/** {instant (ms), 1 si le recul est absent}. */
private final ArrayDeque<long[]> resultats = new ArrayDeque<>();
/**
* Le serveur vient d'appliquer un recul.
*
* @param dirX,dirZ direction du déplacement attendu (vecteur unitaire horizontal)
* @param force force effective (après résistance au recul)
*/
public void recul(long nowMs, double dirX, double dirZ, double force, GardeConfig cfg) {
if (force < cfg.velociteForceMin) return;
double norme = Math.hypot(dirX, dirZ);
if (norme < 1e-6) return;
if (actif) {
ambigu = true; // deuxième recul dans la fenêtre : la mesure ne veut plus rien dire
return;
}
actif = true;
ticksBloques = 0;
ambigu = false;
debutMs = nowMs;
this.dirX = dirX / norme;
this.dirZ = dirZ / norme;
this.force = force;
parcouru = 0;
}
/**
* Un paquet de mouvement accepté.
*
* @param neutre exemption ou milieu qui rend la mesure invalide : la mesure en cours est abandonnée
* @return points d'infraction (0 si rien)
*/
public double mouvement(long nowMs, double dx, double dz, boolean neutre, boolean bloque, GardeConfig cfg) {
if (!actif) return 0;
if (neutre) {
actif = false;
return 0;
}
// Obstacle dans le SENS du recul : un seul tick ne suffit pas à annuler la mesure (un mur latéral, ou un
// contact d'un tick, ne l'annule jamais) ; deux ticks bloqués ou plus l'abandonnent.
if (bloque && ++ticksBloques >= TICKS_BLOQUES_ABANDON) {
actif = false;
return 0;
}
parcouru += dx * dirX + dz * dirZ;
if (nowMs - debutMs < cfg.velociteFenetreTicks * 50L) return 0;
actif = false;
if (ambigu) return 0;
boolean absent = parcouru < cfg.velociteRapportMin * DISTANCE_PAR_FORCE * force;
resultats.addLast(new long[] {nowMs, absent ? 1 : 0});
while (resultats.size() > HISTORIQUE || (!resultats.isEmpty() && nowMs - resultats.peekFirst()[0] > VALIDITE_MS)) {
resultats.removeFirst();
}
if (!absent) return 0;
int n = 0;
for (long[] r : resultats) n += (int) r[1];
return n >= cfg.velociteSerieMin ? cfg.velocitePoints : 0;
}
public boolean actif() { return actif; }
public double dirX() { return dirX; }
public double dirZ() { return dirZ; }
/** Mesure impossible (joueur coincé) : rien n'est compté. */
public void abandonner() {
actif = false;
}
public void vider() {
actif = false;
resultats.clear();
}
}
+42 -1
Voir le fichier
@@ -60,10 +60,12 @@ public final class VolVertical {
*/
public double enregistrer(EtatMouvement e, boolean exempt) {
int n = e.ticks();
// Flottement : évalué avant tout retour anticipé, pour qu'un trou de ticks ne le remette pas à zéro.
double ptsFlottement = flottement(exempt || e.milieuSpecial() || e.auSolServeur(), e.dy(), n);
if (n > TICKS_MAX || n < 0) {
aVitesse = false;
avance = 0;
return 0;
return ptsFlottement;
}
boolean enAir = !e.auSolServeur();
double dy = e.dy();
@@ -106,6 +108,8 @@ public final class VolVertical {
}
}
points = Math.max(points, ptsFlottement);
derniereVitesse = vitesseFin;
aVitesse = true;
etaitEnAir = enAir;
@@ -138,6 +142,42 @@ public final class VolVertical {
return points;
}
// --- 0.4.0 : flottement (remplace le « kicked for floating too long » vanilla, coupé par allow-flight=true) ---
/** Vanilla : un paquet dont le dy est >= -0,03125 sans appui est « flottant » (ServerGamePacketListenerImpl). */
public static final double DY_FLOTTANT = -0.03125;
/** Ticks flottants consécutifs avant infraction (80 comme vanilla) ; 0 = coupé. Réglé par le moteur. */
int flottementMax;
private int flottementTicks;
/**
* Ticks consécutifs en l'air (sol serveur, hors milieu spécial et exemption) sans vraie chute : un joueur qui
* hover, monte lentement ou reste immobile en l'air. Compté en ticks écoulés et non en paquets : un joueur
* immobile n'envoie qu'un paquet toutes les 20 ticks. Une vraie chute (dy par tick sous le seuil), le sol, un
* milieu spécial ou une exemption remettent le compteur à zéro.
*/
private double flottement(boolean neutre, double dy, int ticks) {
if (flottementMax <= 0) {
flottementTicks = 0;
return 0;
}
// Remise à zéro seulement sur une preuve : sol confirmé par le serveur, milieu spécial, exemption.
if (neutre) {
flottementTicks = 0;
return 0;
}
// Paquet à 0 tick (doublon, rotation seule) : neutre, ni remise à zéro ni ajout (anti-contournement).
if (ticks <= 0) return 0;
// Vraie chute (dy par tick sous le seuil vanilla) : preuve que le joueur ne flotte pas.
if (dy / ticks < DY_FLOTTANT) {
flottementTicks = 0;
return 0;
}
// Un trou de plus de TICKS_MAX ticks (lag réel ou simulé) ne remet pas à zéro : il ajoute les ticks écoulés,
// au plus TICKS_MAX par paquet (un seul trou, que rien ne confirme, ne suffit pas ; plusieurs, oui).
flottementTicks = Math.min(100_000, flottementTicks + Math.min(ticks, TICKS_MAX));
return flottementTicks > flottementMax ? 1.5 : 0;
}
private void viderFenetre() {
java.util.Arrays.fill(fenetre, false);
fenetreIndex = 0;
@@ -152,6 +192,7 @@ public final class VolVertical {
etaitEnAir = false;
anormauxConsecutifs = 0;
avance = 0;
flottementTicks = 0;
viderFenetre();
}
}
+76
Voir le fichier
@@ -0,0 +1,76 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.10) : X-Ray statistique, alerte seulement (jamais de setback ni d'expulsion, même en ENFORCE). Un joueur
* qui voit les minerais à travers la pierre casse une part anormale de minerais rares (diamant, débris antiques) parmi
* les blocs cassés en profondeur, et surtout les atteint sans les avoir vus : le minerai n'a aucune face à l'air ou à un
* fluide au moment de la casse. Un minage en branche honnête trouve ses minerais dans les parois du tunnel (exposés),
* et seul le premier bloc d'un filon peut être caché (les suivants touchent le trou).
*
* Sur les {@link #FENETRE} derniers blocs cassés sous {@link GardeConfig#xrayAlerteYMax} : au moins
* {@link GardeConfig#xrayRaresMin} rares, plus de {@link GardeConfig#xrayAlerteDiamantsParCent} % de rares, et une part
* de rares non exposés d'au moins {@link GardeConfig#xrayAlerteNonExposesPart}. Après une alerte, la fenêtre repart de
* zéro. Valeurs prudentes [À VÉRIFIER avec les journaux] : un filon chanceux ne suffit pas (seuil de rares).
*/
public final class XrayStats {
public static final int FENETRE = 400;
/** 0 = bloc ordinaire, 1 = rare exposé, 2 = rare non exposé. */
private final byte[] blocs = new byte[FENETRE];
private int taille;
private int tete;
private int rares;
private int caches;
/** Un bloc cassé. @param y hauteur ; @param rare minerai rare ; @param expose une face à l'air ou à un fluide */
public double casse(int y, boolean rare, boolean expose, GardeConfig cfg) {
if (y > cfg.xrayAlerteYMax) return 0;
byte v = (byte) (rare ? (expose ? 1 : 2) : 0);
if (taille == FENETRE) {
byte ancien = blocs[tete];
if (ancien > 0) rares--;
if (ancien == 2) caches--;
} else {
taille++;
}
blocs[tete] = v;
tete = (tete + 1) % FENETRE;
if (v > 0) rares++;
if (v == 2) caches++;
if (!rare || rares < Math.max(1, cfg.xrayRaresMin)) return 0;
boolean taux = rares * 100.0 / taille > cfg.xrayAlerteDiamantsParCent;
boolean masques = partCachee() >= cfg.xrayAlerteNonExposesPart;
if (!taux || !masques) return 0;
resume = String.format(java.util.Locale.ROOT, "%d minerais rares sur %d blocs casses sous y=%d, %.0f %% non exposes",
rares, taille, cfg.xrayAlerteYMax, partCachee() * 100);
vider();
return 2.0;
}
private String resume = "";
/** Résumé de la dernière alerte (pour le journal). */
public String resume() {
return resume;
}
public int rares() {
return rares;
}
public int taille() {
return taille;
}
public double partCachee() {
return rares == 0 ? 0 : (double) caches / rares;
}
public void vider() {
taille = 0;
tete = 0;
rares = 0;
caches = 0;
}
}
+33
Voir le fichier
@@ -0,0 +1,33 @@
package com.gastinelgarde.mixin;
import com.gastinelgarde.Garde;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.network.ServerGamePacketListenerImpl;
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.callback.CallbackInfo;
/**
* 0.5 (P3.7) : débit des demandes de complétion de commande. Vanilla analyse chaque demande sans limite de débit.
* En ENFORCE, une demande en excès est ignorée (pas de réponse) ; sinon rien ne change.
*
* Règle (F01) : injecté juste APRÈS ensureRunningOnSameThread (cible unique dans la méthode, sources NeoForge
* 21.1.234), donc une seule fois, sur le thread serveur.
*/
@Mixin(ServerGamePacketListenerImpl.class)
public abstract class CompletionMixin {
@Shadow public ServerPlayer player;
@Inject(method = "handleCustomCommandSuggestions",
at = @At(value = "INVOKE",
target = "Lnet/minecraft/network/protocol/PacketUtils;ensureRunningOnSameThread(Lnet/minecraft/network/protocol/Packet;Lnet/minecraft/network/PacketListener;Lnet/minecraft/server/level/ServerLevel;)V",
shift = At.Shift.AFTER),
cancellable = true)
private void gastinelgarde$completion(net.minecraft.network.protocol.game.ServerboundCommandSuggestionPacket packet,
CallbackInfo ci) {
if (player != null && Garde.noterCompletion(player)) ci.cancel();
}
}
+35
Voir le fichier
@@ -0,0 +1,35 @@
package com.gastinelgarde.mixin;
import com.gastinelgarde.Garde;
import net.minecraft.network.protocol.game.ServerboundContainerClickPacket;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.network.ServerGamePacketListenerImpl;
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.callback.CallbackInfo;
/**
* 0.6 (P2.6) : clics de conteneur (ChestStealer, InvCleaner, AutoArmor). Hors ENFORCE, rien ne change ; en ENFORCE au
* palier SETBACK, le clic est ignoré et le menu renvoyé au client.
*
* Règle (F01) : injecté juste APRÈS ensureRunningOnSameThread (MixinsThreadTest), donc sur le thread serveur.
*/
@Mixin(ServerGamePacketListenerImpl.class)
public abstract class ContainerClickMixin {
@Shadow public ServerPlayer player;
@Inject(method = "handleContainerClick",
at = @At(value = "INVOKE",
target = "Lnet/minecraft/network/protocol/PacketUtils;ensureRunningOnSameThread(Lnet/minecraft/network/protocol/Packet;Lnet/minecraft/network/PacketListener;Lnet/minecraft/server/level/ServerLevel;)V",
shift = At.Shift.AFTER),
cancellable = true)
private void gastinelgarde$clicConteneur(ServerboundContainerClickPacket packet, CallbackInfo ci) {
if (player != null && Garde.noterClicConteneur(player, packet.getContainerId(), packet.getSlotNum(),
packet.getClickType())) {
ci.cancel();
}
}
}
+4 -1
Voir le fichier
@@ -77,7 +77,10 @@ public abstract class MovePacketMixin {
target = "Lnet/minecraft/server/network/ServerGamePacketListenerImpl;teleport(DDDFF)V"))
private void gastinelgarde$refusVanilla(net.minecraft.network.protocol.game.ServerboundMovePlayerPacket packet,
CallbackInfo ci) {
if (player != null) Garde.annoncerTeleport(player, GraceTeleport.Origine.REFUS_VANILLA);
if (player == null) return;
// 0.6 (P3.5) : position déclarée dans un bloc solide ? (avant l'annonce, qui ne change pas la grâce de toute façon)
Garde.refusMouvement(player, packet.getX(player.getX()), packet.getY(player.getY()), packet.getZ(player.getZ()));
Garde.annoncerTeleport(player, GraceTeleport.Origine.REFUS_VANILLA);
}
// Renvoi d'une téléportation non confirmée au bout d'une seconde : garde l'origine de la précédente.
+5
Voir le fichier
@@ -0,0 +1,5 @@
# 0.4.0 : lecture seule des champs prives de la fusee de feu d'artifice, pour n'accorder la grace de propulsion
# qu'a une fusee REELLEMENT attachee au joueur en plane (voir GardeEvents.onFusee). Aucune ecriture, aucun comportement change.
public net.minecraft.world.entity.projectile.FireworkRocketEntity attachedToEntity
public net.minecraft.world.entity.projectile.FireworkRocketEntity lifetime
public net.minecraft.world.entity.projectile.FireworkRocketEntity life
+1 -1
Voir le fichier
@@ -4,7 +4,7 @@ license="MIT"
[[mods]]
modId="gastinelgarde"
version="0.3.0"
version="${mod_version}"
displayName="GastinelGarde"
authors="Théo Gastinel"
description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.'''
+1 -1
Voir le fichier
@@ -3,6 +3,6 @@
"minVersion": "0.8",
"package": "com.gastinelgarde.mixin",
"compatibilityLevel": "JAVA_21",
"mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin"],
"mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin", "CompletionMixin", "ContainerClickMixin"],
"injectors": {"defaultRequire": 1}
}
+336
Voir le fichier
@@ -0,0 +1,336 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.GardeConfig;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Set;
import net.neoforged.neoforge.common.ModConfigSpec;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.InvokeDynamicInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
/**
* Câblage Minecraft (constat C4 ⚠️), partie qui demande les classes du jeu mais pas de serveur : événements
* NeoForge abonnés, gardes d'expulsion lues dans le bytecode, types d'entités (C18, F20), options (C7, C8, C10, C15,
* C18) du fichier toml jusqu'à la configuration du moteur.
*/
class CablageMinecraftTest {
// --- Bytecode ---
private static ClassNode lire(Class<?> c) throws Exception {
try (InputStream in = c.getResourceAsStream("/" + c.getName().replace('.', '/') + ".class")) {
assertNotNull(in, c.getName());
ClassNode n = new ClassNode();
new ClassReader(in).accept(n, 0);
return n;
}
}
/** Méthodes appelées par une méthode et par ses lambdas (récursivement, dans la même classe). */
private static Set<String> appels(ClassNode classe, String methode) {
Set<String> sortie = new HashSet<>();
Set<String> vues = new HashSet<>();
parcourir(classe, methode, sortie, vues);
return sortie;
}
private static void parcourir(ClassNode classe, String methode, Set<String> sortie, Set<String> vues) {
if (!vues.add(methode)) return;
boolean trouvee = false;
for (MethodNode m : classe.methods) {
if (!m.name.equals(methode)) continue;
trouvee = true;
for (AbstractInsnNode i : m.instructions) {
if (i instanceof MethodInsnNode mi) {
sortie.add(mi.owner.substring(mi.owner.lastIndexOf('/') + 1) + "." + mi.name);
} else if (i instanceof InvokeDynamicInsnNode d) {
for (Object a : d.bsmArgs) {
if (a instanceof org.objectweb.asm.Handle h && h.getOwner().equals(classe.name)) {
parcourir(classe, h.getName(), sortie, vues);
} else if (a instanceof org.objectweb.asm.Handle h) {
sortie.add(h.getOwner().substring(h.getOwner().lastIndexOf('/') + 1) + "." + h.getName());
}
}
}
}
}
assertTrue(trouvee, methode);
}
@Test
void C4_lesPointsDEntreeConsultentLaMarqueDExpulsion() throws Exception {
ClassNode garde = lire(Garde.class);
ClassNode events = lire(GardeEvents.class);
assertTrue(appels(garde, "avantMouvement").contains("Moteur.estExpulse"));
assertTrue(appels(garde, "avantMouvement").contains("Cablage.evaluerAvantMouvement"));
assertTrue(appels(garde, "apresMouvement").contains("Moteur.estExpulse"));
assertTrue(appels(garde, "apresMouvement").contains("Cablage.traiterApresMouvement"));
assertTrue(appels(events, "onAttaque").contains("Moteur.estExpulse"));
assertTrue(appels(events, "onAttaque").contains("Cablage.entreeAttaque"));
assertTrue(appels(events, "onConnexion").contains("Moteur.oublierExpulsion"), "reconnexion : marque effacée");
assertFalse(appels(events, "onDeconnexion").contains("Moteur.oublierExpulsion"),
"la marque survit à la déconnexion (C6)");
assertTrue(appels(garde, "appliquerSanctionMouvement").contains("Cablage.appliquerSanction"));
Set<String> sanction = appels(lire(Cablage.class), "appliquerSanction");
assertTrue(sanction.contains("Moteur.expulser"));
assertTrue(sanction.contains("Moteur.apresSetback"));
assertFalse(appels(garde, "appliquerSanctionMouvement").stream().anyMatch(a -> a.toLowerCase().contains("ban")),
"jamais de bannissement");
}
/**
* FAILLE (16/10, trouvée en écrivant ces tests) : apresVehicule ne regarde pas la marque d'expulsion, à la
* différence de avantMouvement / apresMouvement / onAttaque. Un paquet de véhicule traité après l'expulsion
* (même lot de paquets, avant la fermeture de la connexion) est encore évalué : journal, alerte aux ops,
* stopRiding + setback, et l'état du moteur (Suivi) est recréé. L'expulsion elle-même reste unique
* (Moteur.expulser). Ce test est vert tant que le défaut existe. Proposition : en tête d'apresVehicule,
* {@code if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;}
* (même garde, et idem pour auSolPourChute, qui peut encore appeler le moteur). Non corrigé : décision de Théo.
*/
@Test
void FAILLE_C4_apresVehiculeNeConsultePasLaMarqueDExpulsion() throws Exception {
ClassNode garde = lire(Garde.class);
Set<String> a = appels(garde, "apresVehicule");
assertTrue(a.contains("Moteur.vehicule"), "le paquet de véhicule est bien évalué par le moteur");
assertFalse(a.contains("Moteur.estExpulse"), "défaut corrigé : inverser en CORRIGE_");
assertFalse(appels(garde, "auSolPourChute").contains("Moteur.estExpulse"));
}
// --- Événements NeoForge abonnés ---
@Test
void evenementsAbonnes() {
Set<Class<?>> ev = new HashSet<>();
for (Method m : GardeEvents.class.getDeclaredMethods()) {
if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) {
assertEquals(1, m.getParameterCount(), m.getName());
assertTrue(java.lang.reflect.Modifier.isStatic(m.getModifiers()), m.getName());
ev.add(m.getParameterTypes()[0]);
}
}
for (Class<?> c : new Class<?>[] {
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerChangedDimensionEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerRespawnEvent.class,
net.neoforged.neoforge.event.tick.ServerTickEvent.Pre.class,
net.neoforged.neoforge.event.tick.ServerTickEvent.Post.class,
net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent.Stop.class,
net.neoforged.neoforge.event.server.ServerStartingEvent.class,
net.neoforged.neoforge.event.server.ServerStoppedEvent.class}) {
assertTrue(ev.contains(c), c.getName());
}
assertTrue(net.neoforged.bus.api.ICancellableEvent.class.isAssignableFrom(
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class), "un coup peut être annulé");
}
@Test
void lesFauxJoueursNeSontJamaisControles() {
// GardeEvents filtre « p instanceof FakePlayer » : un FakePlayer est un ServerPlayer.
assertTrue(net.minecraft.server.level.ServerPlayer.class.isAssignableFrom(
net.neoforged.neoforge.common.util.FakePlayer.class));
}
// --- Types d'entités (C18 GardeAntiCrash, F20 vehiculeControle / etatVehicule) ---
@Test
void C18_seulsLesMinecartsContenantsSontGardesImmobiles() {
Class<?> container = net.minecraft.world.Container.class;
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartChest.class));
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartHopper.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.Minecart.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartTNT.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartFurnace.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartSpawner.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartCommandBlock.class));
}
@Test
void F20_vehiculesControles() {
Class<?> bateau = net.minecraft.world.entity.vehicle.Boat.class;
Class<?> monture = net.minecraft.world.entity.LivingEntity.class;
assertTrue(bateau.isAssignableFrom(net.minecraft.world.entity.vehicle.ChestBoat.class), "bateau à coffre, radeau");
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.horse.Horse.class));
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.Pig.class));
Class<?> minecart = net.minecraft.world.entity.vehicle.AbstractMinecart.class;
assertFalse(bateau.isAssignableFrom(minecart) || monture.isAssignableFrom(minecart),
"minecart : non contrôlé (type AUTRE), la position de retour suit le joueur");
}
// --- Options : du fichier toml au moteur ---
private static Object valeur(String champ) throws Exception {
Field f = GardeSpec.class.getDeclaredField(champ);
f.setAccessible(true);
return f.get(null);
}
@SuppressWarnings("unchecked")
private static <T> T defaut(String champ) throws Exception {
return ((ModConfigSpec.ConfigValue<T>) valeur(champ)).getDefault();
}
@Test
void optionsDesactiveesParDefautDansLeFichierEtLeMoteur() throws Exception {
GardeConfig c = new GardeConfig();
assertEquals(false, defaut("ELYTRES_STRICTE"));
assertEquals(c.elytresExemptionStricte, defaut("ELYTRES_STRICTE"));
assertEquals(2, (int) defaut("ELYTRES_AIR_MIN"));
assertEquals(c.elytresAirMinTicks, (int) defaut("ELYTRES_AIR_MIN"));
assertEquals(false, defaut("COMBAT_VEHICULE"));
assertEquals(c.combatMesureEnVehicule, defaut("COMBAT_VEHICULE"));
assertEquals(false, defaut("VOL_FENETRE_GLISSANTE"));
assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE"));
assertEquals(false, defaut("VITESSE_MOYENNE"));
assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE"));
assertEquals(20, (int) defaut("TIMER_SOLDE_MAX")); // 0.5 (P1.12) : 20 par défaut (avant 0)
assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX"));
assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE"));
assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT"));
assertFalse(new com.gastinelgarde.core.AntiCrashEntites.Reglages().empilementSeulementEnMouvement);
assertFalse(GardeSpec.antiCrash().empilementSeulementEnMouvement, "fichier non chargé : défaut");
}
@Test
void laConfigProposeeNActivePasLesNouvellesOptions() throws Exception {
// Les tests tournent dans build/minecraft-junit : on remonte jusqu'à la racine du projet.
Path toml = null;
for (Path d = Path.of("").toAbsolutePath(); d != null && toml == null; d = d.getParent()) {
Path f = d.resolve("config-proposee").resolve("gastinelgarde-server.toml");
if (Files.exists(f)) toml = f;
}
Assumptions.assumeTrue(toml != null, "config-proposee introuvable depuis " + Path.of("").toAbsolutePath());
String t = Files.readString(toml, StandardCharsets.UTF_8);
for (String cle : new String[] {"elytresExemptionStricte", "combatMesureEnVehicule", "volFenetreGlissante",
"vitesseMoyenne", "empilementSeulementEnMouvement"}) {
assertFalse(t.matches("(?s).*\\b" + cle + "\\s*=\\s*true.*"), cle);
}
assertFalse(t.matches("(?s).*\\btimerSoldeMax\\s*=\\s*[1-9].*"), "timerSoldeMax");
}
/**
* GardeSpec.appliquer recopie bien chaque option dans GardeConfig. On charge le fichier en mémoire
* (ModConfigSpec.acceptConfig, par réflexion : signature propre à NeoForge 21.1), puis on le décharge.
*/
@Test
void appliquerRecopieLesOptionsDuFichier() throws Exception {
Object charge = chargerEnMemoire();
Assumptions.assumeTrue(charge != null, "[À VÉRIFIER] chargement en mémoire du ModConfigSpec impossible ici");
try {
assertTrue(GardeSpec.SPEC.isLoaded());
GardeConfig vide = new GardeConfig();
GardeSpec.appliquer(vide);
assertFalse(vide.elytresExemptionStricte);
assertFalse(vide.combatMesureEnVehicule);
assertFalse(vide.volFenetreGlissante);
assertFalse(vide.vitesseMoyenne);
assertEquals(20, vide.timerSoldeMax); // 0.5 (P1.12)
for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) {
assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k);
}
((ModConfigSpec.BooleanValue) valeur("ELYTRES_STRICTE")).set(true);
((ModConfigSpec.IntValue) valeur("ELYTRES_AIR_MIN")).set(5);
((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true);
((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true);
((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true);
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(35);
GardeConfig c = new GardeConfig();
GardeSpec.appliquer(c);
assertTrue(c.elytresExemptionStricte, "C7");
assertEquals(5, c.elytresAirMinTicks, "C7");
assertTrue(c.combatMesureEnVehicule, "C8");
assertTrue(c.volFenetreGlissante, "C10");
assertTrue(c.vitesseMoyenne, "C15");
assertEquals(35, c.timerSoldeMax, "C15");
} finally {
dechargerEnMemoire();
}
assertFalse(GardeSpec.SPEC.isLoaded(), "les autres tests attendent un fichier non chargé");
}
/** null si l'API n'est pas celle attendue (le test est alors ignoré, pas faux). */
private static Object chargerEnMemoire() {
try {
Method accept = null;
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) accept = m;
}
if (accept == null) return null;
Class<?> type = accept.getParameterTypes()[0];
com.electronwill.nightconfig.core.CommentedConfig cc =
com.electronwill.nightconfig.core.CommentedConfig.inMemory();
// Fichier déjà corrigé (valeurs par défaut) : acceptConfig n'a rien à sauvegarder.
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("correct") && m.getParameterCount() == 1
&& m.getParameterTypes()[0].isInstance(cc)) {
m.invoke(GardeSpec.SPEC, cc);
break;
}
}
Object config = null;
if (type.isInstance(cc)) {
config = cc;
} else if (type.isSealed()) {
// NeoForge 21.1 : IConfigSpec.ILoadedConfig est scellée, seule implémentation LoadedConfig.
for (Class<?> impl : type.getPermittedSubclasses()) {
for (java.lang.reflect.Constructor<?> k : impl.getDeclaredConstructors()) {
Class<?>[] p = k.getParameterTypes();
if (p.length == 0 || !p[0].isInstance(cc)) continue;
Object[] args = new Object[p.length];
args[0] = cc;
k.setAccessible(true);
config = k.newInstance(args);
break;
}
if (config != null) break;
}
} else if (type.isInterface()) {
config = Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] {type}, (o, m, a) -> switch (m.getName()) {
case "config" -> cc;
case "hashCode" -> System.identityHashCode(o);
case "equals" -> o == a[0];
case "toString" -> "config-en-memoire";
default -> null;
});
}
if (config == null) return null;
accept.invoke(GardeSpec.SPEC, config);
return GardeSpec.SPEC.isLoaded() ? config : null;
} catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
System.out.println("[CablageMinecraftTest] chargement en mémoire impossible : " + e);
dechargerEnMemoire();
return null;
}
}
private static void dechargerEnMemoire() {
try {
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) {
m.invoke(GardeSpec.SPEC, new Object[] {null});
}
}
} catch (ReflectiveOperationException | RuntimeException e) {
System.out.println("[CablageMinecraftTest] déchargement : " + e);
}
}
}
+157
Voir le fichier
@@ -0,0 +1,157 @@
package com.gastinelgarde;
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 com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
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;
import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** Défauts (a) et (b) du 23/10 : analyse reproduite en test, et correctif (b) du motif de sanction. */
class CablageSuspicionTest {
private static Verdict verdict(Controle c, Mode m, Sanction palier, Sanction applicable) {
return new Verdict(c, m, 1, 5, palier, applicable, false, "", List.of());
}
// --- (b) motif de la sanction ---
@Test
void b_leMotifEstCeluiDuVerdictQuiSanctionneEtPasLePremierDeLaListe() {
// Cas du 23/10 : vitesse en OBSERVE (alerte) en tête de liste, le vol (ENFORCE) déclenche le setback.
List<Verdict> vs = List.of(
verdict(Controle.VITESSE, Mode.OBSERVE, Sanction.SETBACK, Sanction.ALERTE),
verdict(Controle.VOL, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK));
assertEquals("vol", Cablage.raison(vs, Sanction.SETBACK));
assertEquals("vitesse", Cablage.raison(vs, Sanction.ALERTE));
assertEquals("vol", Cablage.raison(vs, Verdict.pire(vs)));
}
@Test
void b_journalEtDeconnexionPortentLeBonMotif() {
Moteur moteur = new Moteur(new GardeConfig());
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
List<Verdict> vs = List.of(
verdict(Controle.VITESSE, Mode.OBSERVE, Sanction.EXPULSION, Sanction.ALERTE),
verdict(Controle.REGULARITE, Mode.ENFORCE, Sanction.EXPULSION, Sanction.EXPULSION));
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, vs);
assertEquals("journal Tricheur EXPULSE (regularite)", p.actions.get(0));
assertEquals("deconnexion Expulsé par l'anti-triche (regularite).", p.actions.get(1));
}
@Test
void b_sansVerdictOuSansCorrespondanceExacteRienNeCasse() {
assertEquals("anti-triche", Cablage.raison(List.of(), Sanction.EXPULSION));
List<Verdict> vs = List.of(verdict(Controle.VOL, Mode.ENFORCE, Sanction.ALERTE, Sanction.ALERTE));
assertEquals("vol", Cablage.raison(vs, Sanction.SETBACK), "à défaut, le plus sévère");
}
private static Verdict verdictVl(Controle c, double vl, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 1, vl, s, s, false, "", List.of());
}
@Test
void b_P13_egaliteDePalierLePlusFortVlGagne() {
// VITESSE est avant VOL dans l'enum : avant 0.5, le premier gagnait.
List<Verdict> vs = List.of(verdictVl(Controle.VITESSE, 11, Sanction.SETBACK),
verdictVl(Controle.VOL, 18, Sanction.SETBACK));
assertEquals("vol", Cablage.raison(vs, Sanction.SETBACK));
assertEquals("vol ; aussi : vitesse", Cablage.motifJournal(vs, Sanction.SETBACK));
// À VL égal, le premier reste retenu (stable).
List<Verdict> egaux = List.of(verdictVl(Controle.VITESSE, 12, Sanction.SETBACK),
verdictVl(Controle.VOL, 12, Sanction.SETBACK));
assertEquals("vitesse", Cablage.raison(egaux, Sanction.SETBACK));
}
@Test
void b_P13_journalListeLesAutresControlesMaisPasLeMessageAuJoueur() {
Moteur moteur = new Moteur(new GardeConfig());
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
List<Verdict> vs = List.of(verdictVl(Controle.CADENCE, 21, Sanction.EXPULSION),
verdictVl(Controle.REGULARITE, 30, Sanction.EXPULSION),
verdictVl(Controle.VITESSE, 5, Sanction.ALERTE));
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, vs);
assertEquals("journal Tricheur EXPULSE (regularite ; aussi : cadence)", p.actions.get(0));
assertEquals("deconnexion Expulsé par l'anti-triche (regularite).", p.actions.get(1));
// Même contrôle deux fois au palier (deux verdicts killaura-angle) : pas de doublon.
List<Verdict> doubles = List.of(verdictVl(Controle.KILLAURA_ANGLE, 21, Sanction.EXPULSION),
verdictVl(Controle.KILLAURA_ANGLE, 22, Sanction.EXPULSION));
assertEquals("killaura-angle", Cablage.motifJournal(doubles, Sanction.EXPULSION));
}
// --- (a) expulsion « au premier score » après reconnexion : mécanisme prouvé ---
@Test
void a_apresReconnexionLEtatEstNeufMaisLeJournalNeMontrePasLesVerdictsIntermediaires() {
GardeConfig cfg = new GardeConfig();
cfg.mode(Controle.REGULARITE, Mode.ENFORCE);
Moteur moteur = new Moteur(cfg);
UUID id = UUID.randomUUID();
// Première session terminée par une expulsion, puis reconnexion (GardeEvents.onConnexion).
assertTrue(moteur.expulser(id, 0));
moteur.oublierExpulsion(id);
// Reconnexion : Moteur.oublierExpulsion a vidé le suivi (VL à zéro, pas de setback en mémoire).
Suivi neuf = moteur.suivi(id);
assertEquals(0, neuf.vl.total(0));
assertFalse(moteur.estExpulse(id));
// Le client triche toujours : mêmes coups à 20 par seconde, parfaitement réguliers.
Verdict premier = null;
Verdict expulsion = null;
int nPremier = 0;
int n = 0;
long debut = 1_000_000;
List<Verdict> tous = new ArrayList<>();
while (expulsion == null && n < 200) {
n++;
long now = debut + n * 50L;
for (Verdict v : moteur.attaque(id, now, EtatJoueur.normal(), -1, 1, true)) {
if (v.controle() != Controle.REGULARITE) continue;
tous.add(v);
if (premier == null) {
premier = v;
nPremier = n;
}
if (v.applicable() == Sanction.EXPULSION) expulsion = v;
}
}
assertTrue(premier != null && expulsion != null);
// Ce que Théo a lu dans le journal : un premier score de 2,0 au palier JOURNAL...
assertEquals(2.0, premier.vl(), 1e-9);
assertEquals(Sanction.JOURNAL, premier.palier());
// ... puis l'expulsion moins d'une seconde plus tard (10 coups), sans autre ligne de journal car
// Suivi.autoriserJournal limite à une ligne par seconde et par contrôle.
assertTrue(n - nPremier <= 12, "expulsion " + (n - nPremier) * 50 + " ms après le premier score");
long tPremier = debut + nPremier * 50L;
long tExpulsion = debut + n * 50L;
assertTrue(neuf.autoriserJournal(Controle.REGULARITE, tPremier, 1000));
assertFalse(neuf.autoriserJournal(Controle.REGULARITE, tExpulsion, 1000),
"la ligne du verdict qui expulse n'est pas écrite");
}
@Test
void a_unJoueurReconnecteEnLAirNAPasDePositionDeRetourDoncPasDeSetback() {
Moteur moteur = new Moteur(new GardeConfig());
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
UUID id = p.id();
moteur.oublierExpulsion(id); // reconnexion
assertFalse(moteur.suivi(id).aPositionValide());
List<Verdict> vs = List.of(verdict(Controle.VOL, Mode.ENFORCE, Sanction.SETBACK, Sanction.SETBACK));
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, vs);
assertEquals(0, p.compte("teleport"), "pas de position valide : aucun setback possible");
// 0.5 (P1.1) : le setback raté est désormais écrit (avant : aucune ligne).
assertEquals(1, p.compte("journal Tricheur SETBACK impossible (vol)"));
// Le VL de vol n'est donc pas remis à zéro (apresSetback non appelé) et continue vers l'expulsion.
}
}
+335
Voir le fichier
@@ -0,0 +1,335 @@
package com.gastinelgarde;
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 com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.Exemptions;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BooleanSupplier;
import org.junit.jupiter.api.Test;
/**
* Câblage Minecraft (constat C4 ⚠️) : décisions de Garde / GardeEvents sorties dans {@link Cablage}, testées sans
* serveur avec une doublure du joueur et un vrai {@link Moteur}.
*/
class CablageTest {
static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
private static final String MONDE = "minecraft:overworld";
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
static class FauxJoueur implements Cablage.Joueur {
final List<String> actions = new ArrayList<>();
String dimension = MONDE;
int tick = 1000;
@Override public UUID id() { return ID; }
@Override public String nom() { return "Tricheur"; }
@Override public String dimension() { return dimension; }
@Override public int tick() { return tick; }
@Override public void annoncerTeleport(GraceTeleport.Origine o) { actions.add("annonce " + o); }
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
actions.add(String.format(java.util.Locale.ROOT, "teleport %.1f %.1f %.1f %.0f %.0f", x, y, z, yaw, pitch));
}
@Override public void deconnecter(String message) { actions.add("deconnexion " + message); }
@Override public void journal(String ligne) { actions.add("journal " + ligne); }
long compte(String prefixe) {
return actions.stream().filter(a -> a.startsWith(prefixe)).count();
}
}
private static Verdict verdict(Controle c, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
}
private static BooleanSupplier compteur(AtomicInteger n, boolean valeur) {
return () -> {
n.incrementAndGet();
return valeur;
};
}
// --- Expulsion unique (C4) ---
@Test
void C4_expulsionUneSeuleFoisPuisDeNouveauApresReconnexion() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.EXPULSION));
for (int i = 0; i < 344; i++) { // incident du 15/10 : 344 disconnect en 18 s
p.tick++;
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
}
assertEquals(1, p.compte("deconnexion"), p.actions.toString());
assertEquals(1, p.compte("journal"));
assertEquals("journal Tricheur EXPULSE (vol)", p.actions.get(0)); // journal avant la déconnexion
assertEquals("deconnexion Expulsé par l'anti-triche (vol).", p.actions.get(1));
assertTrue(moteur.estExpulse(ID));
// GardeEvents.onConnexion : oublierExpulsion, la prochaine expulsion est de nouveau possible.
moteur.oublierExpulsion(ID);
assertFalse(moteur.estExpulse(ID));
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
assertEquals(2, p.compte("deconnexion"));
}
@Test
void C4_apresLExpulsionPlusAucuneEvaluationNiCoup() {
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, false));
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, true)); // l'expulsion passe avant
assertEquals(Cablage.EntreeAttaque.IGNORER, Cablage.entreeAttaque(false, true));
assertEquals(Cablage.EntreeAttaque.EVALUER, Cablage.entreeAttaque(false, false));
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.evaluerAvantMouvement(true, () -> true, compteur(lus, false)));
assertEquals(0, lus.get(), "expulsé : l'exemption n'est même pas lue");
assertFalse(Cablage.evaluerAvantMouvement(true, () -> false, () -> true)); // exemption manuelle
assertTrue(Cablage.evaluerAvantMouvement(true, () -> false, () -> false));
assertFalse(Cablage.traiterApresMouvement(true, () -> true));
assertTrue(Cablage.traiterApresMouvement(true, () -> false));
}
@Test
void F01_horsDuThreadServeurLEtatDuModNEstPasLu() {
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.evaluerAvantMouvement(false, compteur(lus, false), compteur(lus, false)));
assertFalse(Cablage.traiterApresMouvement(false, compteur(lus, false)));
assertEquals(0, lus.get());
}
@Test
void expulsionSansVerdictRaisonParDefaut() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of());
assertEquals("journal Tricheur EXPULSE (anti-triche)", p.actions.get(0));
}
// --- Setback (C2, C3) ---
@Test
void v042_setbackVelociteRameneLaPositionEtExpulsionAutoTotemDeconnecte() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VELOCITE, Sanction.SETBACK)));
assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (velocite)"),
p.actions);
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of(verdict(Controle.AUTO_TOTEM, Sanction.EXPULSION)));
assertEquals(1, p.compte("deconnexion"));
assertTrue(moteur.estExpulse(ID));
}
@Test
void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
long ms = p.tick * 50L;
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
moteur.suivi(ID).vl.ajouter(Controle.VOL, 30, ms);
moteur.suivi(ID).vl.ajouter(Controle.VITESSE, 20, ms);
moteur.suivi(ID).vl.ajouter(Controle.KILLAURA_CIBLES, 7, ms);
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (vol)"),
p.actions, "la grâce est annoncée avant le teleport (F05)");
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VOL, ms), 1e-9);
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VITESSE, ms), 1e-9);
assertTrue(moteur.suivi(ID).vl.valeur(Controle.KILLAURA_CIBLES, ms) > 6.9, "les autres VL ne sont pas touchées");
assertFalse(moteur.estExpulse(ID));
}
@Test
void setbackSansPositionOuAutreDimensionNeFaitRien() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.SETBACK));
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
// 0.5 (P1.1) : aucun téléport, mais le setback raté est journalisé.
assertEquals(0, p.compte("teleport"), "aucune position de retour : pas de teleport");
assertEquals(1, p.compte("journal Tricheur SETBACK impossible"));
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
assertEquals(0, p.compte("teleport"), "position dans une autre dimension : jamais de teleport inter-dimension");
assertEquals(2, p.compte("journal Tricheur SETBACK impossible"));
}
@Test
void sanctionsInferieuresAuSetbackNeTouchentPasLeJoueur() {
Moteur moteur = new Moteur(new GardeConfig());
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, MONDE);
FauxJoueur p = new FauxJoueur();
for (Sanction s : new Sanction[] {Sanction.AUCUNE, Sanction.JOURNAL, Sanction.ALERTE}) {
Cablage.appliquerSanction(moteur, p, s, List.of(verdict(Controle.VOL, s)));
assertFalse(Cablage.sanctionDeMouvement(s), s.name());
}
assertTrue(p.actions.isEmpty());
assertTrue(Cablage.sanctionDeMouvement(Sanction.SETBACK));
assertTrue(Cablage.sanctionDeMouvement(Sanction.EXPULSION));
}
@Test
void C3_positionDeRetourSeulementAuSolEtSansVerdictNiVehicule() {
Moteur moteur = new Moteur(new GardeConfig());
int tick = 500;
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, true, false));
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, true), "eau, échelle…");
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, false), "en l'air");
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> true, true, false), "véhicule contrôlé");
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.memoriserRetour(moteur, tick, tick, compteur(lus, false), true, false), "verdict ce tick");
assertEquals(0, lus.get(), "le véhicule n'est pas lu si un verdict est tombé à ce tick");
}
// --- Coups (GardeEvents.onAttaque) ---
@Test
void coupAnnuleEnEnforceOuSurSanctionEtExpulsionSeuleAppliquee() {
for (Sanction s : Sanction.values()) {
boolean grave = s.ordinal() >= Sanction.SETBACK.ordinal();
assertEquals(grave, Cablage.annulerCoup(false, s), s.name());
assertTrue(Cablage.annulerCoup(true, s), "portée / hitbox ENFORCE : " + s);
assertEquals(s == Sanction.EXPULSION, Cablage.appliquerApresCoup(s), "pas de setback sur un coup : " + s);
}
}
@Test
void cibleSurContraptionOuVaisseauPasDeMesurePorteeHitbox() {
BooleanSupplier oui = () -> true;
BooleanSupplier non = () -> false;
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, non, non));
assertFalse(Cablage.mesurerPorteeHitbox(oui, non, true, non, non), "cible contraption");
assertFalse(Cablage.mesurerPorteeHitbox(non, oui, true, non, non), "cible sur vaisseau Sable");
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, oui, non), "assise sur un siège Create");
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, non, oui), "véhicule sur un vaisseau");
assertTrue(Cablage.mesurerPorteeHitbox(non, non, false, non, non), "cheval, bateau : mesuré");
AtomicInteger lus = new AtomicInteger();
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, compteur(lus, true), compteur(lus, true)));
assertEquals(0, lus.get(), "sans véhicule, la racine n'est pas interrogée");
}
// --- C7 : élytres ---
@Test
void C7_deploiementTropTotApresLeSolEstSuspectPourTouteLaDureeDuPlane() {
Cablage.Elytres e = new Cablage.Elytres();
int sol = 100;
e.observer(false, sol, 100, 2);
e.observer(true, sol, 101, 2); // 1 tick après le sol (onGround falsifié)
assertTrue(e.suspectes);
for (int t = 102; t < 300; t++) e.observer(true, sol, t, 2);
assertTrue(e.suspectes, "reste suspect jusqu'à la fin du plané");
e.observer(false, sol, 300, 2);
assertFalse(e.suspectes);
assertFalse(e.vues);
Cablage.Elytres h = new Cablage.Elytres();
h.observer(true, sol, 102, 2); // 2 ticks en l'air : honnête
assertFalse(h.suspectes);
Cablage.Elytres jamais = new Cablage.Elytres();
jamais.observer(true, Integer.MIN_VALUE, 5, 2); // jamais vu au sol (connexion en plein vol)
assertFalse(jamais.suspectes);
}
@Test
void C7_unSolServeurVuPendantLePlaneNeRendPasSuspectApresCoup() {
Cablage.Elytres e = new Cablage.Elytres();
e.observer(true, 100, 120, 2);
assertFalse(e.suspectes);
e.observer(true, 125, 125, 2); // frôle un bloc en plané
assertFalse(e.suspectes, "seul le début du plané compte");
}
@Test
void C7_cableJusquAuxExemptions_avecEtSansOption() {
Cablage.Elytres e = new Cablage.Elytres();
e.observer(true, 100, 101, 2);
EtatJoueur etat = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(e.suspectes).build();
GardeConfig defaut = new GardeConfig();
assertFalse(defaut.elytresExemptionStricte, "option désactivée par défaut");
assertTrue(Exemptions.evaluer(etat, defaut, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
GardeConfig stricte = new GardeConfig();
stricte.elytresExemptionStricte = true;
assertFalse(Exemptions.evaluer(etat, stricte, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
}
// --- C8 : combat en véhicule ---
@Test
void C8_passagerMesureSeulementAvecLOptionEtContraptionToujoursExemptee() {
EtatJoueur cheval = EtatJoueur.builder().enVehicule(true).build();
EtatJoueur siege = EtatJoueur.builder().enVehicule(true).pocheContraption(true).build();
GardeConfig defaut = new GardeConfig();
assertFalse(defaut.combatMesureEnVehicule);
assertTrue(Exemptions.evaluer(cheval, defaut, Exemptions.Famille.COMBAT).exempt());
GardeConfig option = new GardeConfig();
option.combatMesureEnVehicule = true;
assertFalse(Exemptions.evaluer(cheval, option, Exemptions.Famille.COMBAT).exempt());
assertTrue(Exemptions.evaluer(siege, option, Exemptions.Famille.COMBAT).raisons().contains("contraption"));
assertTrue(Exemptions.evaluer(cheval, option, Exemptions.Famille.MOUVEMENT).raisons().contains("vehicule"),
"l'option ne touche que le combat");
}
// --- Cache des détections (contraption, courant d'air) ---
@Test
void cacheDeDetectionToutesLesDixTicksPuisGrace() {
Cablage.CacheDetection c = new Cablage.CacheDetection();
AtomicInteger appels = new AtomicInteger();
boolean[] present = {true};
BooleanSupplier detecter = () -> {
appels.incrementAndGet();
return present[0];
};
assertTrue(c.lire(100, detecter, 40));
assertEquals(1, appels.get());
present[0] = false; // la contraption s'éloigne
assertTrue(c.lire(109, detecter, 40), "valeur en cache");
assertEquals(1, appels.get());
assertTrue(c.lire(110, detecter, 40), "redétecté (absent) mais dans la grâce");
assertEquals(2, appels.get());
assertTrue(c.lire(140, detecter, 40));
assertFalse(c.lire(150, detecter, 40), "grâce terminée");
assertTrue(c.lire(5, () -> true, 40), "tick qui recule (redémarrage) : redétecté");
}
@Test
void cacheJamaisVuPasDeGrace() {
Cablage.CacheDetection c = new Cablage.CacheDetection();
assertFalse(c.lire(100, () -> false, 40));
}
// --- 0.6.1 (revue M1/M4) ---
@Test
void M1_deuxSetbacksDuMemePaquetUnSeulRetour() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
long ms = p.tick * 50L;
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
moteur.suivi(ID).vl.ajouter(Controle.JESUS, 40, ms);
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK)));
assertEquals(1, p.compte("teleport"));
assertEquals(1, p.compte("journal Tricheur SETBACK deja applique ce tick"));
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.JESUS, ms), 1e-9, "M4 : VL de jesus remis à zéro");
p.tick++;
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK)));
assertEquals(2, p.compte("teleport"), "tick suivant : nouveau setback");
}
}
+41
Voir le fichier
@@ -0,0 +1,41 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
/** Grâce de propulsion d'une fusée (0.4.0, revue de sécurité) : seulement attachée, en plané, vie réelle. */
class FuseeElytresTest {
@Test
void fuseeNonAttacheeArbaleteOuPoseeAuSolPasDeGrace() {
assertEquals(0, Cablage.graceFusee(false, true, false, 0, 30));
assertEquals(0, Cablage.graceFusee(false, false, false, 0, 30));
}
@Test
void fuseeAttacheeSansPlanePasDeGrace() {
assertEquals(0, Cablage.graceFusee(true, false, false, 0, 30));
}
@Test
void fuseeRechargeeDuDisquePasDeGrace() {
assertEquals(0, Cablage.graceFusee(true, true, true, 0, 30));
}
@Test
void fuseeAttacheeEnPlaneGraceLimiteeALaDureeDeVie() {
assertEquals(30 + Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 0, 30));
assertEquals(10 + Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 20, 30), "vie restante");
assertEquals(Cablage.MARGE_FUSEE_TICKS, Cablage.graceFusee(true, true, false, 50, 30), "déjà finie");
assertTrue(Cablage.graceFusee(true, true, false, 0, 100_000) <= Cablage.VIE_FUSEE_MAX + Cablage.MARGE_FUSEE_TICKS, "durée de vie aberrante bornée");
}
@Test
void uneFuseeParSecondeNeDonneJamaisPlusQueLaVieDeLaFusee() {
int graceMax = 0;
for (int i = 0; i < 20; i++) graceMax = Math.max(graceMax, Cablage.graceFusee(true, true, false, 0, 30));
assertTrue(graceMax <= 30 + Cablage.MARGE_FUSEE_TICKS, "chaque grâce vaut la vie de la fusée (~30 ticks) + marge (0.4.1 : 20), pas 120 ticks fixes");
}
}
+110
Voir le fichier
@@ -0,0 +1,110 @@
package com.gastinelgarde;
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 com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
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;
import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P1.1 : tout verdict de SETBACK / EXPULSION est écrit, et le setback raté aussi. */
class JournalP1Test {
private static Verdict verdict(Controle c, Sanction applicable) {
return new Verdict(c, Mode.ENFORCE, 1, 5, applicable, applicable, false, "", List.of());
}
/** Ce que fait Garde.traiter pour le journal, sans serveur : lignes écrites pour une suite de verdicts. */
private static List<Verdict> ecrits(Suivi s, GardeConfig cfg, List<Verdict> vs, long nowMs) {
List<Verdict> out = new ArrayList<>();
long delai = Cablage.delaiJournalMs(cfg.journalLignesParSeconde);
for (Verdict v : vs) {
if (Cablage.ecrireVerdict(v, cfg.journalToujoursSanctions,
() -> s.autoriserJournal(v.controle(), nowMs, delai))) out.add(v);
}
return out;
}
@Test
void dixVerdictsDansLaMemeSecondeLaLigneDeLExpulsionExiste() {
GardeConfig cfg = new GardeConfig();
cfg.mode(Controle.REGULARITE, Mode.ENFORCE);
Moteur moteur = new Moteur(cfg);
UUID id = UUID.randomUUID();
Suivi s = moteur.suivi(id);
List<Verdict> tous = new ArrayList<>();
Verdict expulsion = null;
long debut = 1_000_000;
for (int n = 1; n <= 200 && expulsion == null; n++) {
long now = debut + n * 50L;
List<Verdict> vs = new ArrayList<>();
for (Verdict v : moteur.attaque(id, now, EtatJoueur.normal(), -1, 1, true)) {
if (v.controle() == Controle.REGULARITE) vs.add(v);
}
for (Verdict v : ecrits(s, cfg, vs, now)) tous.add(v);
for (Verdict v : vs) if (v.applicable() == Sanction.EXPULSION) expulsion = v;
}
assertTrue(expulsion != null);
assertTrue(tous.contains(expulsion), "la ligne du verdict qui expulse est écrite");
assertTrue(tous.stream().anyMatch(v -> v.applicable() == Sanction.SETBACK), "le setback aussi");
}
@Test
void limiteToujoursAppliqueeAuxVerdictsOrdinaires() {
GardeConfig cfg = new GardeConfig();
Suivi s = new Suivi(0.5, cfg);
List<Verdict> vs = new ArrayList<>();
for (int i = 0; i < 10; i++) vs.add(verdict(Controle.VOL, Sanction.ALERTE));
assertEquals(1, ecrits(s, cfg, vs, 5000).size());
// Plusieurs lignes par seconde si réglé ainsi
cfg.journalLignesParSeconde = 4;
assertEquals(250, Cablage.delaiJournalMs(4));
assertEquals(1000, Cablage.delaiJournalMs(0), "borne basse");
}
@Test
void optionCoupeeAncienComportement() {
GardeConfig cfg = new GardeConfig();
cfg.journalToujoursSanctions = false;
Suivi s = new Suivi(0.5, cfg);
List<Verdict> vs = List.of(verdict(Controle.VOL, Sanction.ALERTE), verdict(Controle.VOL, Sanction.EXPULSION));
assertEquals(1, ecrits(s, cfg, vs, 5000).size());
cfg.journalToujoursSanctions = true;
Suivi s2 = new Suivi(0.5, cfg);
assertEquals(2, ecrits(s2, cfg, vs, 5000).size());
}
@Test
void verdictDeSanctionNeConsommePasLaLimite() {
GardeConfig cfg = new GardeConfig();
Suivi s = new Suivi(0.5, cfg);
List<Verdict> vs = List.of(verdict(Controle.VOL, Sanction.SETBACK), verdict(Controle.VOL, Sanction.ALERTE));
assertEquals(2, ecrits(s, cfg, vs, 5000).size(), "l'alerte suivante a encore sa ligne");
}
@Test
void setbackImpossibleEcritAvecLaRaison() {
Moteur moteur = new Moteur(new GardeConfig());
CablageTest.FauxJoueur p = new CablageTest.FauxJoueur();
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(List.of("journal Tricheur SETBACK impossible (vol) : pas de position de retour valide"), p.actions);
// Position mémorisée dans une autre dimension
moteur.suivi(p.id()).memoriserPosition(1, 64, 1, 0, 0, "minecraft:the_nether");
CablageTest.FauxJoueur p2 = new CablageTest.FauxJoueur();
Cablage.appliquerSanction(moteur, p2, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(0, p2.compte("teleport"));
assertTrue(p2.actions.get(0).contains("autre dimension (minecraft:the_nether)"));
assertFalse(p2.actions.get(0).contains("pas de position"));
}
}
+12 -1
Voir le fichier
@@ -73,7 +73,8 @@ class MixinsThreadTest {
@Test
void F01_aucune_injection_HEAD_dans_un_handle() throws Exception {
for (String classe : new String[] {"com.gastinelgarde.mixin.MovePacketMixin", "com.gastinelgarde.mixin.RiptideMoveMixin"}) {
for (String classe : new String[] {"com.gastinelgarde.mixin.MovePacketMixin", "com.gastinelgarde.mixin.RiptideMoveMixin",
"com.gastinelgarde.mixin.CompletionMixin", "com.gastinelgarde.mixin.ContainerClickMixin"}) {
for (Injection i : injections(lire(classe))) {
if (!visePaquet(i) || i.at() == null) continue;
assertFalse("HEAD".equals(valeur(i.at(), "value")),
@@ -82,6 +83,16 @@ class MixinsThreadTest {
}
}
@Test
void F01_completion_apres_ensureRunningOnSameThread() throws Exception {
Injection i = injections(lire("com.gastinelgarde.mixin.CompletionMixin")).stream()
.filter(x -> x.methode().equals("gastinelgarde$completion")).findFirst().orElseThrow();
assertEquals("INVOKE", valeur(i.at(), "value"));
assertEquals(ENSURE, valeur(i.at(), "target"));
Object shift = valeur(i.at(), "shift");
assertTrue(shift instanceof String[] s && s.length == 2 && "AFTER".equals(s[1]), "shift = AFTER");
}
@Test
void F01_debut_du_mouvement_apres_ensureRunningOnSameThread() throws Exception {
Injection avant = injections(lire("com.gastinelgarde.mixin.MovePacketMixin")).stream()
+112
Voir le fichier
@@ -0,0 +1,112 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.EtatMouvement;
import com.gastinelgarde.core.Exemptions;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Verdict;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P1.2 : grâce de connexion, plus longue après une expulsion récente ; setback au sol sans position. */
class ReconnexionP1Test {
private static Verdict verdict(Controle c, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 1, 15, s, s, false, "", List.of());
}
@Test
void dureeDeLaGraceSelonLExpulsionRecente() {
Moteur m = new Moteur(new GardeConfig());
UUID id = UUID.randomUUID();
assertEquals(100, m.graceConnexionTicks(id, 0));
assertTrue(m.expulser(id, 1_000));
m.oublierExpulsion(id); // reconnexion
assertEquals(200, m.graceConnexionTicks(id, 2_000), "expulsé il y a 1 s");
assertEquals(200, m.graceConnexionTicks(id, 1_000 + Moteur.EXPULSION_RECENTE_MS));
assertEquals(100, m.graceConnexionTicks(id, 2_000 + Moteur.EXPULSION_RECENTE_MS), "plus de 10 min après");
}
@Test
void connexionRecenteExempteMouvementVehiculeEtTimerPasLeCombat() {
GardeConfig cfg = new GardeConfig();
EtatJoueur e = EtatJoueur.builder().connexionRecente(true).build();
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.MOUVEMENT).raisons().contains("connexion"));
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.VEHICULE).raisons().contains("connexion"));
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.TIMER).raisons().contains("connexion"));
assertTrue(!Exemptions.evaluer(e, cfg, Exemptions.Famille.COMBAT).exempt(), "le combat reste mesuré");
}
@Test
void suiviNeufEnLAirPasDExpulsionPendantLaGrace() {
GardeConfig cfg = new GardeConfig();
cfg.mode(Controle.VOL, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
UUID id = UUID.randomUUID();
EtatJoueur enGrace = EtatJoueur.builder().connexionRecente(true).build();
// Flottement immobile en l'air (dy = 0) pendant 100 ticks : en vrai, vol ; ici, grâce de connexion.
for (int t = 0; t < 100; t++) {
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
assertTrue(m.mouvement(id, t * 50L, enGrace, em).isEmpty(), "tick " + t);
}
// Après la grâce, le contrôle reprend (référence remise à zéro, puis infraction).
boolean vu = false;
for (int t = 100; t < 400 && !vu; t++) {
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
vu = !m.mouvement(id, t * 50L, EtatJoueur.normal(), em).isEmpty();
}
assertTrue(vu, "le vol est de nouveau contrôlé après la grâce");
}
/** Doublure qui trouve le sol 12 blocs plus bas. */
static final class JoueurAuDessusDuSol extends CablageTest.FauxJoueur {
double[] sol = {10.5, 52.0, -3.5, 90, 0};
@Override public double[] solSous() { return sol; }
}
@Test
void setbackAuSolSansPositionDeRetour() {
Moteur moteur = new Moteur(new GardeConfig());
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals("annonce SETBACK", p.actions.get(0));
assertEquals("teleport 10.5 52.0 -3.5 90 0", p.actions.get(1));
assertEquals("journal Tricheur SETBACK au sol (vol) : pas de position de retour, y=52.00", p.actions.get(2));
assertEquals(0.0, moteur.suivi(p.id()).vl.valeur(Controle.VOL, p.tick() * 50L), 1e-9, "VL de vol remis à zéro");
}
@Test
void setbackAuSolDesactiveOuSolIntrouvable() {
GardeConfig cfg = new GardeConfig();
cfg.setbackSolSiPasDePosition = false;
Moteur moteur = new Moteur(cfg);
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(0, p.compte("teleport"));
assertEquals(1, p.compte("journal Tricheur SETBACK impossible"));
Moteur m2 = new Moteur(new GardeConfig());
JoueurAuDessusDuSol vide = new JoueurAuDessusDuSol();
vide.sol = null; // vide sous le joueur
Cablage.appliquerSanction(m2, vide, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(0, vide.compte("teleport"));
assertEquals(1, vide.compte("journal Tricheur SETBACK impossible"));
}
@Test
void autreDimensionJamaisDeSetbackAuSol() {
Moteur moteur = new Moteur(new GardeConfig());
moteur.suivi(CablageTest.ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(0, p.compte("teleport"), "une position existe (autre dimension) : pas de secours au sol");
}
}
+31
Voir le fichier
@@ -0,0 +1,31 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.GardeConfig;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;
/** 0.6 : chaque réglage des sections [inventaire], [scaffold], [blink], [phase] a son champ dans GardeConfig. */
class Reglages06Test {
@Test
void chaqueCleA0nChampDuMemeNomEtLeMemeDefaut() throws Exception {
String src = Files.readString(Path.of(System.getProperty("gastinelgarde.projet", "."), "src/main/java/com/gastinelgarde/GardeSpec.java"));
Matcher m = Pattern.compile("V06\\.put\\(\"(\\w+)\".*?defineInRange\\(\"(\\w+)\", ([0-9.]+),", Pattern.DOTALL).matcher(src);
GardeConfig c = new GardeConfig();
int n = 0;
while (m.find()) {
assertEquals(m.group(1), m.group(2), "cle et champ");
java.lang.reflect.Field f = GardeConfig.class.getField(m.group(1));
double defaut = f.getType() == int.class ? f.getInt(c) : f.getDouble(c);
assertEquals(Double.parseDouble(m.group(3)), defaut, 1e-9, m.group(1));
n++;
}
assertTrue(n >= 19, "reglages trouves : " + n);
}
}
+54
Voir le fichier
@@ -0,0 +1,54 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;
/** 0.5, P1.4 : la version du neoforge.mods.toml traité est celle de gradle.properties (une seule source). */
class VersionP1Test {
/** Dossier du projet (le répertoire de travail des tests unitaires NeoForge n'est pas la racine). */
private static Path projet() {
return Path.of(System.getProperty("gastinelgarde.projet", "."));
}
private static String versionGradle() throws Exception {
Properties p = new Properties();
try (InputStream in = Files.newInputStream(projet().resolve("gradle.properties"))) {
p.load(in);
}
return p.getProperty("mod_version");
}
@Test
void modsTomlTraiteAVersionDeGradleProperties() throws Exception {
String attendu = versionGradle();
assertNotNull(attendu);
assertEquals(attendu, System.getProperty("gastinelgarde.version", attendu));
String toml;
try (InputStream in = VersionP1Test.class.getClassLoader().getResourceAsStream("META-INF/neoforge.mods.toml")) {
assertNotNull(in, "neoforge.mods.toml absent des ressources traitées");
toml = new String(in.readAllBytes(), StandardCharsets.UTF_8);
}
assertFalse(toml.contains("${"), "expansion non faite");
Matcher m = Pattern.compile("(?m)^version=\"([^\"]+)\"").matcher(toml);
assertTrue(m.find());
assertEquals(attendu, m.group(1));
}
@Test
void sourceDuTomlNEcritPasLaVersionEnDur() throws Exception {
String source = Files.readString(projet().resolve("src/main/resources/META-INF/neoforge.mods.toml"), StandardCharsets.UTF_8);
assertTrue(source.contains("version=\"${mod_version}\""), "double source de vérité");
}
}
+49
Voir le fichier
@@ -0,0 +1,49 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
/** 0.5, P1.13 : automate START / ABORT de casse de bloc (diagnostic « Mismatch in destroy block pos »). */
class ActionsBlocP1Test {
@Test
void startPuisAbortMemePositionRien() {
ActionsBloc a = new ActionsBloc();
a.start(1, 64, 2, false);
assertNull(a.abort(1, 64, 2, 1000));
assertEquals(0, a.incoherences());
}
@Test
void abortSansStartCommeLeMessageVanilla() {
ActionsBloc a = new ActionsBloc();
String l = a.abort(5, 70, -3, 1000);
assertTrue(l.contains("ABORT (5,70,-3)") && l.contains("aucun START vu"), l);
}
@Test
void startAnnuleParUnModEstSignale() {
ActionsBloc a = new ActionsBloc();
a.start(5, 70, -3, true); // protection de zone : destroyPos vanilla pas mis à jour
String l = a.abort(5, 70, -3, 1000);
assertTrue(l.contains("annule par un mod"), l);
}
@Test
void autrePositionEtLimiteDeJournal() {
ActionsBloc a = new ActionsBloc();
a.start(0, 64, 0, false);
assertTrue(a.abort(1, 64, 0, 1000) != null);
assertNull(a.abort(2, 64, 0, 5000), "moins de 10 s : compté, pas écrit");
String l = a.abort(3, 64, 0, 1000 + ActionsBloc.DELAI_JOURNAL_MS);
assertTrue(l.contains("3 incoherence(s)"), l);
}
@Test
void diagnosticActifParDefaut() {
assertTrue(new GardeConfig().diagnosticActionsBloc);
}
}
+69
Voir le fichier
@@ -0,0 +1,69 @@
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, P1.8 : anti-faim (course au sol déclarée « en l'air »). */
class AntiFaimP1Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** Course à 0,28 bloc/tick sur du plat (sprint vanilla), sol serveur vrai. */
private static EtatMouvement course(boolean solClient, double dy) {
return new EtatMouvement(0.28, dy, 1, solClient, true, true, false, false, 0, 0, false, false);
}
private double total(Moteur m, int paquets, java.util.function.IntFunction<EtatMouvement> f) {
double pts = 0;
for (int i = 0; i < paquets; i++) {
for (Verdict v : m.mouvement(joueur, (i + 1) * 50L, EtatJoueur.normal(), f.apply(i))) {
if (v.controle() == Controle.ANTI_FAIM) pts += v.points();
}
}
return pts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.ANTI_FAIM));
assertEquals(Controle.ANTI_FAIM, Controle.parse("anti-faim"));
}
@Test
void courseDeclareeEnLAirVue() {
assertTrue(total(new Moteur(cfg), 20, i -> course(false, 0)) > 0, "20 paquets de suite");
assertEquals(0, total(new Moteur(cfg), 19, i -> course(false, 0)), 1e-9, "19 : pas encore");
}
@Test
void courseHonneteEtSautsRien() {
assertEquals(0, total(new Moteur(cfg), 200, i -> course(true, 0)), 1e-9, "au sol déclaré");
// Sprint-saut : en l'air avec dy non nul, puis au sol.
double[] saut = {0.42, 0.333, 0.248, 0.165, 0.083, 0.0, -0.078, -0.155, -0.23, -0.303, -0.375, -0.13};
assertEquals(0, total(new Moteur(cfg), 240, i -> {
int k = i % (saut.length + 1);
return k == saut.length ? course(true, 0) : course(false, saut[k]);
}), 1e-9);
}
@Test
void uneInterruptionRemetLaSerieAZero() {
assertEquals(0, total(new Moteur(cfg), 200, i -> i % 15 == 14 ? course(true, 0) : course(false, 0)), 1e-9);
}
@Test
void sansSprintMarcheLenteOuMilieuSpecialRien() {
EtatMouvement marche = new EtatMouvement(0.21, 0, 1, false, true, false, false, false, 0, 0, false, false);
assertEquals(0, total(new Moteur(cfg), 100, i -> marche), 1e-9, "marche : vanilla ne coûte rien");
EtatMouvement lente = new EtatMouvement(0.05, 0, 1, false, true, true, false, false, 0, 0, false, false);
assertEquals(0, total(new Moteur(cfg), 100, i -> lente), 1e-9);
EtatMouvement eau = new EtatMouvement(0.28, 0, 1, false, true, true, false, false, 0, 0, true, false);
assertEquals(0, total(new Moteur(cfg), 100, i -> eau), 1e-9);
EtatMouvement airServeur = new EtatMouvement(0.28, 0, 1, false, false, true, false, false, 0, 0, false, false);
assertEquals(0, total(new Moteur(cfg), 100, i -> airServeur), 1e-9, "en l'air aussi pour le serveur : vol");
}
}
+60
Voir le fichier
@@ -0,0 +1,60 @@
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.1 : auto-cristal (âge du cristal de l'End au moment du coup). */
class AutoCristalP3Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** Un coup par seconde, âges donnés. */
private double frapper(Moteur m, EtatJoueur etat, int... ages) {
double pts = 0;
for (int i = 0; i < ages.length; i++) {
for (Verdict v : m.frappeCristal(joueur, 10_000L + i * 1000L, etat, ages[i])) {
if (v.controle() == Controle.AUTO_CRISTAL) pts += v.points();
}
}
return pts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.AUTO_CRISTAL));
assertEquals(Controle.AUTO_CRISTAL, Controle.parse("auto-cristal"));
assertEquals(2, Controle.AUTO_CRISTAL.fiabilite());
}
@Test
void cristauxFrappesAuTickDePoseVus() {
assertTrue(frapper(new Moteur(cfg), EtatJoueur.normal(), 0, 0, 0, 0, 0, 0, 0, 0) > 0);
}
@Test
void pvpHumainRapideJamaisVu() {
// Deux à cinq ticks entre la pose et le coup, et de temps en temps un tick (paquets groupés).
int[] a = new int[60];
for (int i = 0; i < a.length; i++) a[i] = i % 4 == 0 ? 1 : 2 + i % 4;
assertEquals(0, frapper(new Moteur(cfg), EtatJoueur.normal(), a), 1e-9);
}
@Test
void ageInconnuOuAncienNonMesure() {
assertEquals(0, frapper(new Moteur(cfg), EtatJoueur.normal(), -1, -1, -1, -1, -1, -1, -1, -1, -1, -1), 1e-9);
assertEquals(0, frapper(new Moteur(cfg), EtatJoueur.normal(), 500, 500, 500, 500, 500, 500, 500), 1e-9);
}
@Test
void exemptionsEtLag() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().tps(12).build(),
EtatJoueur.builder().ticksDepuisGel(3).build()}) {
assertEquals(0, frapper(new Moteur(cfg), e, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 1e-9, e.toString());
}
}
}
+91
Voir le fichier
@@ -0,0 +1,91 @@
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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.Exemptions.Famille;
import org.junit.jupiter.api.Test;
/**
* Constats de gravité haute restants de l'autocritique du 16/10 (C7, C8, C18).
* Tests inversés (CORRIGE_) : options désactivées par défaut, vérifiées activées ; défaut inchangé vérifié aussi.
*/
class AutotestConstatsHautsTest {
private final GardeConfig cfg = new GardeConfig();
private GardeConfig strict() {
GardeConfig c = new GardeConfig();
c.elytresExemptionStricte = true;
c.combatMesureEnVehicule = true;
return c;
}
// C7 : élytres déployées depuis le sol (onGround falsifié) : plus d'exemption de mouvement avec l'option.
@Test
void CORRIGE_C7_elytresDeployeesAuSolNExemptentPlus() {
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
assertFalse(Exemptions.evaluer(suspect, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
// Le mouvement est alors contrôlé : un vol plat soutenu donne des points.
Moteur m = new Moteur(strict());
java.util.UUID j = java.util.UUID.randomUUID();
double pts = 0;
for (int i = 0; i < 60; i++) {
for (Verdict v : m.mouvement(j, i * 50L, suspect,
new EtatMouvement(0.3, 0.0, 1, false, false, true, false, false, 0, 0, false, false))) pts += v.points();
}
assertTrue(pts > 0, "vol plat en élytres suspectes : " + pts);
}
// C7 témoin : plané honnête (déployé en l'air) toujours exempté, avec ou sans l'option ; défaut inchangé.
@Test
void temoin_C7_planeHonneteToujoursExempte() {
EtatJoueur honnete = EtatJoueur.builder().elytres(true).build();
assertTrue(Exemptions.evaluer(honnete, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
assertTrue(Exemptions.evaluer(suspect, cfg, Famille.MOUVEMENT).raisons().contains("elytres"), "défaut inchangé");
}
// C7 : portée / hitbox mesurées pendant le plané avec l'option.
@Test
void CORRIGE_C7_porteeMesureeEnElytres() {
EtatJoueur e = EtatJoueur.builder().elytres(true).build();
assertNull(PorteeHitbox.raisonNonMesure(e, 0.0, strict()));
assertEquals("elytres", PorteeHitbox.raisonNonMesure(e, 0.0, cfg), "défaut inchangé");
}
// C8 : passager d'un véhicule : combat mesuré avec l'option.
@Test
void CORRIGE_C8_combatMesureEnVehicule() {
EtatJoueur e = EtatJoueur.builder().enVehicule(true).build();
assertFalse(Exemptions.evaluer(e, strict(), Famille.COMBAT).exempt());
Moteur m = new Moteur(strict());
java.util.UUID j = java.util.UUID.randomUUID();
int verdicts = 0;
for (int i = 0; i < 40; i++) verdicts += m.attaque(j, i * 50L, e, 170.0, 1, true).size();
assertTrue(verdicts > 0);
assertTrue(Exemptions.evaluer(e, cfg, Famille.COMBAT).exempt(), "défaut inchangé");
// La contraption reste une exemption (constat : la garder pour le combat sur contraption).
assertTrue(Exemptions.evaluer(EtatJoueur.builder().pocheContraption(true).build(), strict(), Famille.COMBAT).exempt());
}
// C18 : stockage immobile de minecarts à coffre non cassé avec l'option ; empilement en mouvement ou simple cassé.
@Test
void CORRIGE_C18_stockageImmobileNonCasse() {
AntiCrashEntites.Reglages r = new AntiCrashEntites.Reglages();
r.empilementSeulementEnMouvement = true;
assertFalse(AntiCrashEntites.empilementACasser(6, r, 0.0, true));
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.5, true));
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.0, false));
assertFalse(AntiCrashEntites.empilementACasser(3, r, 0.5, false));
AntiCrashEntites.Reglages d = new AntiCrashEntites.Reglages();
assertTrue(AntiCrashEntites.empilementACasser(6, d, 0.0, true), "défaut inchangé");
}
@Test
void temoin_portee_mesureeAPiedSansElytres() {
assertNull(PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 0.0, cfg));
}
}
+1
Voir le fichier
@@ -307,6 +307,7 @@ class AutotestContournementsTest {
@Test
void CORRIGE_C15_timerA109EstVuAvecLOption() {
assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu");
cfg.timerSoldeMax = 0; // 0.5 (P1.12) : le défaut est passé à 20
assertEquals(0, timer(46, 30), 1e-9, "option coupée : rien (comme avant)");
cfg.timerSoldeMax = 20;
assertTrue(timer(46, 30) > 0, "corrigé : 21,7 paquets/s (timer 1,09) pendant 30 s vu par le solde");
+132
Voir le fichier
@@ -0,0 +1,132 @@
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.6, P3.4 : blink (trou de mouvements pendant que d'autres paquets arrivent). */
class BlinkP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private int mouv(Moteur m, long t, EtatJoueur e, boolean vivant) {
int n = 0;
for (Verdict v : m.mouvementBlink(joueur, t * 50L, t, e, vivant)) if (v.controle() == Controle.BLINK && v.points() > 0) n++;
return n;
}
private int mouv(Moteur m, long t) {
return mouv(m, t, EtatJoueur.normal(), true);
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.BLINK));
assertEquals(Controle.BLINK, Controle.parse("blink"));
}
@Test
void joueurImmobileQuiCliqueNonVu() {
// Immobile : un paquet de position toutes les 20 ticks ; il clique entre deux.
Moteur m = new Moteur(cfg);
int n = 0;
for (long t = 100; t < 1000; t += 20) {
n += mouv(m, t);
for (int k = 2; k < 20; k += 3) m.autrePaquet(joueur, t + k);
}
assertEquals(0, n);
}
@Test
void vraiLagNonVu() {
// Lag réseau : rien pendant 60 ticks, puis tout arrive dans le même tick (clics et mouvements mêlés, dans l'ordre).
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 160);
m.autrePaquet(joueur, 160);
assertEquals(0, mouv(m, 160));
}
@Test
void gelDuClientUnSeulTickNonVu() {
// Gel du client : au rattrapage, un clic part avant le mouvement du même tick client.
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 150);
assertEquals(0, mouv(m, 151));
}
@Test
void blinkVu() {
// Mouvements retenus 40 ticks, coups et clics envoyés pendant le trou.
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
m.autrePaquet(joueur, 135);
assertEquals(1, mouv(m, 140));
// le trou est soldé : le mouvement suivant normal ne compte pas
assertEquals(0, mouv(m, 141));
}
@Test
void autresPaquetsAvantLeRappelNonComptes() {
// Clics dans les 21 premiers ticks : le rappel de position vanilla n'était pas encore dû.
Moteur m = new Moteur(cfg);
mouv(m, 100);
for (long t = 101; t <= 121; t++) m.autrePaquet(joueur, t);
assertEquals(0, mouv(m, 140));
}
@Test
void blinkRepeteMonteAuPalier() {
cfg.mode(Controle.BLINK, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
boolean setback = false;
long t = 100;
mouv(m, t);
for (int i = 0; i < 10; i++) {
m.autrePaquet(joueur, t + 25);
m.autrePaquet(joueur, t + 28);
t += 32;
for (Verdict v : m.mouvementBlink(joueur, t * 50L, t, EtatJoueur.normal(), true)) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true;
}
}
assertTrue(setback);
}
@Test
void exemptions() {
EtatJoueur[] etats = {EtatJoueur.builder().ticksDepuisTeleport(10).build(),
EtatJoueur.builder().connexionRecente(true).build(), EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().ticksDepuisGel(50).build(), EtatJoueur.builder().tps(15).build(),
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build()};
for (EtatJoueur e : etats) {
Moteur m = new Moteur(cfg);
mouv(m, 100, e, true);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
assertEquals(0, mouv(m, 140, e, true), e.toString());
}
// Mort : pas de mouvement sur l'écran de mort
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
assertEquals(0, mouv(m, 140, EtatJoueur.normal(), false));
}
@Test
void etatOublieALaDeconnexion() {
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
m.retirer(joueur);
assertEquals(0, mouv(m, 140)); // nouveau suivi : premier mouvement, rien à solder
}
}
+59
Voir le fichier
@@ -0,0 +1,59 @@
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.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P3.7 : débit des demandes de complétion de commande. */
class CompletionP3Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** n demandes espacées de pasMs ; renvoie [points, ignorées]. */
private double[] demandes(Moteur m, int n, long pasMs) {
double pts = 0;
int ignorees = 0;
for (int i = 0; i < n; i++) {
for (Verdict v : m.completion(joueur, 1_000_000L + i * pasMs, EtatJoueur.normal())) pts += v.points();
if (m.completionAIgnorer(joueur)) ignorees++;
}
return new double[] {pts, ignorees};
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.COMPLETION));
assertEquals(Controle.COMPLETION, Controle.parse("completion"));
}
@Test
void frappeHumaineJamaisVue() {
// 15 frappes par seconde pendant une minute.
assertEquals(0, demandes(new Moteur(cfg), 900, 66)[0], 1e-9);
}
@Test
void rafaleCourteToleree() {
assertEquals(0, demandes(new Moteur(cfg), 40, 0)[0], 1e-9);
}
@Test
void spamVuMaisRienIgnoreEnObserve() {
double[] r = demandes(new Moteur(cfg), 2000, 1);
assertTrue(r[0] > 0);
assertEquals(0, r[1], 1e-9);
}
@Test
void enforceIgnoreChaqueDemandeEnExces() {
cfg.mode(Controle.COMPLETION, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
double[] r = demandes(m, 1000, 0); // 1000 demandes au même instant : 40 servies, 960 ignorées
assertEquals(960, r[1], 1e-9);
assertFalse(new Completion().demande(0, cfg));
}
}
+1
Voir le fichier
@@ -184,6 +184,7 @@ class ControlesTest {
@Test
void timerAttendTroisSecondes() {
cfg.timerSoldeMax = 0; // 0.5 (P1.12) : on mesure ici le débit seul
TimerPaquets t = new TimerPaquets();
double a2000 = -1;
double a3000 = -1;
+117
Voir le fichier
@@ -0,0 +1,117 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P1.10 : auto-criticals (micro-sauts fictifs avant le coup). */
class CriticalsP1Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private long t = 1000;
private static EtatMouvement paquet(double dy, boolean solClient) {
return new EtatMouvement(0, dy, 1, solClient, solClient, false, false, false, 0, 0, false, false);
}
private void bouger(Moteur m, EtatMouvement... suite) {
for (EtatMouvement e : suite) {
t += 50;
m.mouvement(joueur, t, EtatJoueur.normal(), e);
}
}
private double critique(Moteur m) {
return m.critique(joueur, t, EtatJoueur.normal()).stream()
.filter(v -> v.controle() == Controle.CRITICALS).mapToDouble(Verdict::points).sum();
}
@Test
void observeParDefautEtFiabiliteFaible() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.CRITICALS));
assertEquals(2, Controle.CRITICALS.fiabilite());
}
@Test
void microSautsAvantChaqueCoupVusEnSerie() {
Moteur m = new Moteur(cfg);
double total = 0;
int premierCompte = -1;
for (int i = 0; i < 6; i++) {
// Wurst « packet » : +0,0625 puis retour au niveau du sol, onGround faux, puis le coup.
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
double p = critique(m);
if (p > 0 && premierCompte < 0) premierCompte = i + 1;
total += p;
}
assertTrue(total > 0);
assertEquals(3, premierCompte, "rien avant le 3e critique suspect (criticalsSerieMin)");
}
@Test
void vraisSautsJamaisSuspects() {
Moteur m = new Moteur(cfg);
double total = 0;
for (int i = 0; i < 10; i++) {
bouger(m, paquet(0, true), paquet(0.42, false), paquet(0.333, false), paquet(0.248, false),
paquet(0.165, false), paquet(0.083, false), paquet(0.0, false), paquet(-0.078, false));
total += critique(m);
}
assertEquals(0, total, 1e-9);
}
@Test
void chuteDUnRebordAuDeuxiemeTickPasSuspecte() {
Moteur m = new Moteur(cfg);
double total = 0;
for (int i = 0; i < 10; i++) {
bouger(m, paquet(0, true), paquet(-0.078, false), paquet(-0.155, false));
total += critique(m);
}
assertEquals(0, total, 1e-9);
}
@Test
void longueChuteOuMilieuSpecialAbandonneLaReference() {
Moteur m = new Moteur(cfg);
bouger(m, paquet(0, true));
for (int i = 0; i < Criticals.PAQUETS_AIR_MAX + 1; i++) bouger(m, paquet(0, false)); // flottement (vol couvre)
Criticals c = m.suivi(joueur).criticals;
assertTrue(!c.suspect(cfg));
bouger(m, paquet(0, true), paquet(0.0625, false));
assertTrue(c.suspect(cfg));
t += 50;
m.mouvement(joueur, t, EtatJoueur.normal(),
new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, true, false));
assertTrue(!c.suspect(cfg), "eau / échelle");
}
@Test
void exemptionCombatEtModeOff() {
Moteur m = new Moteur(cfg);
for (int i = 0; i < 5; i++) {
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
List<Verdict> v = m.critique(joueur, t, EtatJoueur.builder().enVehicule(true).build());
assertTrue(v.isEmpty(), "passager : exempté");
}
cfg.mode(Controle.CRITICALS, Mode.OFF);
assertTrue(m.critique(joueur, t, EtatJoueur.normal()).isEmpty());
}
@Test
void enforceAtteintLeSetbackPourAnnulerLeCritique() {
cfg.mode(Controle.CRITICALS, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
Sanction pire = Sanction.AUCUNE;
for (int i = 0; i < 10; i++) {
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
Sanction s = Verdict.pire(m.critique(joueur, t, EtatJoueur.normal()));
if (s.ordinal() > pire.ordinal()) pire = s;
}
assertTrue(pire.ordinal() >= Sanction.SETBACK.ordinal(), "" + pire);
}
}
+53
Voir le fichier
@@ -0,0 +1,53 @@
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, P1.6 : déploiements d'élytres répétés (ElytraFly « packet »). */
class ElytresP1Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private double deploiements(Moteur m, EtatJoueur e, long debut, long pasMs, int n) {
double pts = 0;
for (int i = 0; i < n; i++) {
for (Verdict v : m.deploiementElytres(joueur, debut + i * pasMs, e)) pts += v.points();
}
return pts;
}
@Test
void basculeAChaqueDeuxTicksVue() {
// START_FALL_FLYING à chaque tick : plané coupé puis relancé, un déploiement tous les 2 ticks (10 par seconde).
assertTrue(deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 100, 40) > 0);
}
@Test
void redeploiementsHumainsRien() {
// 5 par seconde (au seuil) : rien ; un redéploiement toutes les 2 s : rien.
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 200, 50), 1e-9);
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 2000, 30), 1e-9);
}
@Test
void creatifOuVolAutoriseOuCoupeRien() {
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.builder().creatif(true).build(), 1000, 100, 40), 1e-9);
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.builder().peutVoler(true).build(), 1000, 100, 40), 1e-9);
cfg.elytresDeploiementsMax = 0;
assertEquals(0, deploiements(new Moteur(cfg), EtatJoueur.normal(), 1000, 100, 40), 1e-9, "0 = coupé");
cfg.elytresDeploiementsMax = 5;
cfg.mode(Controle.ELYTRES, Mode.OFF);
assertTrue(new Moteur(cfg).deploiementElytres(joueur, 1000, EtatJoueur.normal()).isEmpty());
}
@Test
void horlogeQuiReculeNeCompteRien() {
DeploiementsElytres d = new DeploiementsElytres();
for (int i = 0; i < 10; i++) d.deploiement(10_000 + i, cfg);
assertEquals(0, d.deploiement(5_000, cfg), 1e-9, "instants futurs ignorés");
}
}
+104
Voir le fichier
@@ -0,0 +1,104 @@
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, P2.3 : fast-break (progression simulée comme ServerPlayerGameMode). */
class FastBreakP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/**
* Casse {@code n} blocs successifs (pierre à la pioche en bois : progression 1/15 par tick environ), chacun en
* {@code ticksCasse} ticks après son START. Renvoie le total des points fast-break.
*/
private double casser(Moteur m, EtatJoueur etat, int n, double progression, int ticksCasse) {
double pts = 0;
long tick = 1000;
for (int i = 0; i < n; i++) {
m.debutCasse(joueur, tick, i, 10, 0);
tick += ticksCasse;
for (Verdict v : m.casseBloc(joueur, tick * 50L, tick, etat, i, 10, 0, progression)) {
if (v.controle() == Controle.FAST_BREAK) pts += v.points();
}
tick += 2;
}
return pts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.FAST_BREAK));
assertEquals(Controle.FAST_BREAK, Controle.parse("fast-break"));
assertEquals(2, Controle.FAST_BREAK.fiabilite());
}
@Test
void casseALaMargeVanillaEnSerieVue() {
// 15 ticks attendus ; casse à 0,7 : progression × (j + 1) >= 0,7 => j = 10.
double p = 1.0 / 15;
assertTrue(casser(new Moteur(cfg), EtatJoueur.normal(), 10, p, 10) > 0);
}
@Test
void casseHonneteJamaisVue() {
double p = 1.0 / 15;
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 14), 1e-9); // rapport 1,0
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 12), 1e-9); // 0,87 : jitter de 2 ticks
}
@Test
void casseSuspecteIsoleeNeComptePas() {
// 3 suspectes sur 10 (seuil 4) : rien.
Moteur m = new Moteur(cfg);
double p = 1.0 / 15;
double pts = casser(m, EtatJoueur.normal(), 7, p, 14);
pts += casser(m, EtatJoueur.normal(), 3, p, 10);
assertEquals(0, pts, 1e-9);
}
@Test
void blocsRapidesEtInstantanesNonMesures() {
// 4 ticks attendus (< fastBreakTicksMin 6) et casse instantanée (progression >= 1) : jamais mesurés.
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 0.25, 1), 1e-9);
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 1.5, 0), 1e-9);
}
@Test
void casseSansStartAuMemeEndroitNonMesuree() {
Moteur m = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < 20; i++) {
m.debutCasse(joueur, 100 + i * 20, 0, 0, 0);
for (Verdict v : m.casseBloc(joueur, (110 + i * 20) * 50L, 110 + i * 20, EtatJoueur.normal(), 5, 5, 5, 1.0 / 15)) {
pts += v.points();
}
}
assertEquals(0, pts, 1e-9);
}
@Test
void exemptions() {
double p = 1.0 / 15;
for (EtatJoueur e : new EtatJoueur[] {
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(),
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().ticksDepuisGel(10).build(),
EtatJoueur.builder().tps(15).build()}) {
assertEquals(0, casser(new Moteur(cfg), e, 20, p, 10), 1e-9, e.toString());
}
}
@Test
void serieFenetreCompteLesDernieres() {
SerieFenetre s = new SerieFenetre(3, 1000);
assertEquals(1, s.ajouter(0, true));
assertEquals(2, s.ajouter(10, true));
assertEquals(2, s.ajouter(20, false));
assertEquals(1, s.ajouter(30, false)); // la première est sortie des 3 dernières
assertEquals(1, s.ajouter(2000, true)); // les autres sont hors fenêtre
}
}
+84
Voir le fichier
@@ -0,0 +1,84 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Random;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P2.4 : fast-place (régularité des poses au tick près). */
class FastPlaceP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private double poser(Moteur m, EtatJoueur etat, long[] ticks) {
double pts = 0;
for (long t : ticks) {
for (Verdict v : m.poseBloc(joueur, t * 50L, t, etat)) {
if (v.controle() == Controle.FAST_PLACE) pts += v.points();
}
}
return pts;
}
private static long[] reguliers(int n, int intervalle) {
long[] t = new long[n];
for (int i = 0; i < n; i++) t[i] = 100 + (long) i * intervalle;
return t;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.FAST_PLACE));
assertEquals(Controle.FAST_PLACE, Controle.parse("fast-place"));
}
@Test
void poseAChaqueTickVue() {
assertTrue(poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(45, 1)) > 0);
}
@Test
void clicMaintenuVanillaJamaisVu() {
// 4 ticks entre deux poses, parfaitement régulier : vanilla.
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(200, 4)), 1e-9);
}
@Test
void delaiUnSeulementSiConfigure() {
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(50, 2)), 1e-9);
cfg.fastPlaceIntervalleMaxTicks = 2;
assertTrue(poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(50, 2)) > 0);
}
@Test
void dragClickIrregulierJamaisVu() {
// Poses de Poisson à 20/s (1 par tick) pendant 60 s, irréaliste (il faudrait 20 cibles par seconde) mais
// pire cas : intervalles 0 (même tick), 1, 2, 3…
Random r = new Random(42);
long[] t = new long[1200];
double temps = 100;
for (int i = 0; i < t.length; i++) {
temps += -Math.log(1 - r.nextDouble()) / 1.0;
t[i] = (long) temps;
}
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), t), 1e-9);
}
@Test
void pauseRemetAZero() {
long[] t = new long[60];
for (int i = 0; i < 60; i++) t[i] = 100 + i + (i >= 30 ? 100 : 0); // 30 + 30 poses séparées de 5 s
assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), t), 1e-9);
}
@Test
void exemptions() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().ticksDepuisGel(3).build()}) {
assertEquals(0, poser(new Moteur(cfg), e, reguliers(60, 1)), 1e-9, e.toString());
}
}
}
+213
Voir le fichier
@@ -0,0 +1,213 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import java.util.function.Consumer;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* 0.4.0 : le contrôle vol remplace le « kicked for floating too long » vanilla (allow-flight=true). Flottement =
* 80 ticks en l'air sans chute, compté en ticks écoulés. Une exemption par cas listé le 23/10 (rapport).
*
* Les paquets sont espacés de 20 ticks (rappel de position d'un joueur immobile) pour que le seul contrôle qui
* parle soit le flottement : l'ancien contrôle de gravité demande 11 paquets anormaux (220 ticks).
*/
class FlottementVolTest {
private GardeConfig cfg;
private Moteur moteur;
private final UUID joueur = UUID.randomUUID();
private long now;
@BeforeEach
void init() {
cfg = new GardeConfig();
cfg.mode(Controle.VOL, Mode.ENFORCE);
cfg.mode(Controle.VITESSE, Mode.OFF);
cfg.mode(Controle.NO_FALL, Mode.OFF);
moteur = new Moteur(cfg);
now = 100_000;
}
private static EtatMouvement hover(int ticks, boolean milieu, boolean sol) {
return new EtatMouvement(0, 0, ticks, sol, sol, false, false, false, 0, 0, milieu, false);
}
/** Envoie n paquets de 20 ticks sans mouvement ; renvoie les points de vol cumulés et le rang du premier. */
private double[] hoverPendant(int paquets, EtatJoueur etat, boolean milieu, boolean sol) {
double total = 0;
int premier = -1;
for (int i = 1; i <= paquets; i++) {
now += 1000;
double pts = moteur.mouvement(joueur, now, etat, hover(20, milieu, sol)).stream()
.filter(v -> v.controle() == Controle.VOL).mapToDouble(Verdict::points).sum();
if (pts > 0 && premier < 0) premier = i;
total += pts;
}
return new double[] {total, premier};
}
@Test
void hoverImmobileEnSurvieEstVuApres80Ticks() {
double[] r = hoverPendant(8, EtatJoueur.normal(), false, false);
assertEquals(5, (int) r[1], "4 paquets = 80 ticks tolérés, le 5e dépasse (comme vanilla)");
assertTrue(r[0] > 0);
}
@Test
void monteeLenteEstVue() {
// +0,02 par tick en l'air, paquets de 1 tick : flottant pour vanilla (dy >= -0,03125)
double total = 0;
for (int i = 0; i < 100; i++) {
now += 50;
EtatMouvement m = new EtatMouvement(0.05, 0.02, 1, false, false, false, false, false, 0, 0, false, false);
total += moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream().mapToDouble(Verdict::points).sum();
}
assertTrue(total > 0);
}
@Test
void chuteReelleNeCompteJamaisEtRemetLeCompteurAZero() {
double total = 0;
double vy = 0;
for (int i = 0; i < 70; i++) { // 70 ticks de chute libre normale
vy = (vy - 0.08) * 0.98;
now += 50;
EtatMouvement m = new EtatMouvement(0, vy, 1, false, false, false, false, false, 0, 0, false, false);
total += moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream().mapToDouble(Verdict::points).sum();
}
assertEquals(0, total);
// 60 ticks de flottement après une chute : le compteur repart de zéro (60 < 80)
double[] r = hoverPendant(3, EtatJoueur.normal(), false, false);
assertEquals(0, r[0]);
}
@Test
void sautOrdinaireNEstPasUnFlottement() {
double vy = 0.42;
double total = 0;
for (int i = 0; i < 12; i++) { // saut complet jusqu'à l'atterrissage
now += 50;
EtatMouvement m = new EtatMouvement(0.2, vy, 1, false, false, true, false, false, 0, 0, false, false);
total += moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream().mapToDouble(Verdict::points).sum();
vy = (vy - 0.08) * 0.98;
}
assertEquals(0, total);
}
@Test
void auSolOuDansUnMilieuSpecialPasDeFlottement() {
assertEquals(0, hoverPendant(20, EtatJoueur.normal(), false, true)[0], "debout au sol");
// eau, lave, échelles, lianes, échafaudage, toile, neige poudreuse, miel, colonne à bulles, slime, tapis Create
assertEquals(0, hoverPendant(20, EtatJoueur.normal(), true, false)[0], "milieu spécial");
}
private void exempt(String nom, Consumer<EtatJoueur.Builder> regle) {
Moteur m = new Moteur(cfg);
EtatJoueur.Builder b = EtatJoueur.builder();
regle.accept(b);
EtatJoueur etat = b.build();
double total = 0;
UUID id = UUID.randomUUID();
for (int i = 0; i < 30; i++) {
now += 1000;
for (Verdict v : m.mouvement(id, now, etat, hover(20, false, false))) total += v.points();
}
assertEquals(0, total, nom + " doit être exempté du flottement");
}
@Test
void exemptionsExplicites() {
exempt("créatif", b -> b.creatif(true));
exempt("spectateur", b -> b.spectateur(true));
exempt("abilities.mayfly accordé par le serveur", b -> b.peutVoler(true));
exempt("élytres (vol plané légitime)", b -> b.elytres(true));
exempt("lévitation", b -> b.levitation(true));
exempt("chute lente", b -> b.chuteLente(true));
exempt("véhicule / passager", b -> b.enVehicule(true));
exempt("riptide", b -> b.riptide(true));
exempt("structure en mouvement Create / Sable", b -> b.pocheContraption(true));
exempt("juste après une téléportation", b -> b.ticksDepuisTeleport(0));
exempt("juste après un recul", b -> b.ticksDepuisRecul(0));
}
@Test
void grandesStructuresLeverUneExemptionRemetLeCompteurAZero() {
// 4 paquets sur une structure (exempté), puis il en descend : il faut 80 ticks de plus, pas 0
EtatJoueur sur = EtatJoueur.builder().pocheContraption(true).build();
hoverPendant(20, sur, false, false);
double[] r = hoverPendant(4, EtatJoueur.normal(), false, false);
assertEquals(0, r[0], "80 ticks tolérés après la fin de l'exemption");
}
@Test
void reglageAZeroCoupeLeFlottement() {
cfg.volFlottementTicks = 0;
assertEquals(0, hoverPendant(8, EtatJoueur.normal(), false, false)[0]);
}
@Test
void flottementDansLaListeDesVerdictsParMoteur() {
double[] r = hoverPendant(6, EtatJoueur.normal(), false, false);
List<Verdict> vs = moteur.mouvement(joueur, now + 1000, EtatJoueur.normal(), hover(20, false, false));
assertTrue(r[0] > 0);
assertTrue(vs.stream().anyMatch(v -> v.controle() == Controle.VOL));
}
private double pts(EtatMouvement m) {
now += 50;
return moteur.mouvement(joueur, now, EtatJoueur.normal(), m).stream()
.filter(v -> v.controle() == Controle.VOL).mapToDouble(Verdict::points).sum();
}
@Test
void contournement_rafaleDePaquetsAZeroTickNeRemetPasLeCompteurAZero() {
for (int i = 0; i < 3; i++) assertEquals(0, pts(hover(20, false, false))); // 60 ticks
for (int i = 0; i < 5; i++) assertEquals(0, pts(hover(0, false, false)), "0 tick : neutre, rien n'est ajouté");
assertEquals(0, pts(hover(20, false, false)), "80 ticks, pas encore au-dessus");
assertTrue(pts(hover(20, false, false)) > 0, "100 ticks : le flottement continue de compter malgré la rafale");
}
@Test
void contournement_rafaleAZeroTickNAjouteRienNonPlus() {
for (int i = 0; i < 5; i++) assertEquals(0, pts(hover(0, false, false)));
assertEquals(0, pts(hover(20, false, false)), "5 paquets à 0 tick n'ont pas fait monter le compteur");
}
@Test
void contournement_trouDeTicksPlusGrandQueTicksMaxCompteLesTicksEcoules() {
for (int i = 0; i < 3; i++) assertEquals(0, pts(hover(20, false, false))); // 60 ticks
assertTrue(VolVertical.TICKS_MAX < 60);
assertTrue(pts(hover(60, false, false)) > 0, "un trou de 60 ticks (> TICKS_MAX) ajoute 40 : 100 > 80");
}
@Test
void contournement_trouSeulSuffitAuSeuil() {
assertEquals(0, pts(hover(100, false, false)), "un seul trou, non confirmé, ajoute au plus TICKS_MAX (40)");
pts(hover(100, false, false));
assertTrue(pts(hover(100, false, false)) > 0, "des trous répétés comptent");
}
@Test
void remiseAZeroSeulementSurPreuve() {
for (int i = 0; i < 3; i++) pts(hover(20, false, false));
pts(hover(20, false, true)); // sol confirmé par le serveur
for (int i = 0; i < 4; i++) assertEquals(0, pts(hover(20, false, false)));
assertTrue(pts(hover(20, false, false)) > 0);
// vraie chute après un trou : remise à zéro aussi
Moteur m2 = new Moteur(cfg);
UUID j = UUID.randomUUID();
for (int i = 0; i < 3; i++) m2.mouvement(j, now += 1000, EtatJoueur.normal(), hover(20, false, false));
m2.mouvement(j, now += 1000, EtatJoueur.normal(),
new EtatMouvement(0, -20, 60, false, false, false, false, false, 0, 0, false, false)); // chute, trou 60 ticks
for (int i = 0; i < 4; i++) {
assertTrue(m2.mouvement(j, now += 1000, EtatJoueur.normal(), hover(20, false, false)).stream()
.noneMatch(v -> v.controle() == Controle.VOL && v.points() > 0));
}
}
}
+173
Voir le fichier
@@ -0,0 +1,173 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P2.5 : interaction-bloc (AirPlace, face cachée, portée, impact forgé). */
class InteractionBlocP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** Bloc plein en (0, 64, 0). */
private static final double[] CUBE = {0, 64, 0, 1, 65, 1};
/** Dalle du bas en (0, 64, 0). */
private static final double[] DALLE = {0, 64, 0, 1, 64.5, 1};
private static final int BAS = 0, HAUT = 1, NORD = 2, SUD = 3, OUEST = 4, EST = 5;
private static String a(double[] oeil, double[] boite, int face, double[] impact, boolean air, boolean plein) {
return InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, 4.5, 0.5);
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.INTERACTION_BLOC));
assertEquals(Controle.INTERACTION_BLOC, Controle.parse("interaction-bloc"));
}
@Test
void clicsVanillaSansAnomalie() {
// Debout sur le bloc voisin, regard vers la face du haut ; face est vue de l'est ; dalle par-dessus.
assertNull(a(new double[] {1.5, 66.62, 0.5}, CUBE, HAUT, new double[] {0.7, 65, 0.5}, false, true));
assertNull(a(new double[] {3.0, 65.62, 0.5}, CUBE, EST, new double[] {1, 64.6, 0.5}, false, true));
assertNull(a(new double[] {0.5, 64.3 + 1.62, 2.0}, DALLE, HAUT, new double[] {0.5, 64.5, 0.9}, false, false));
// Scaffold vanilla (pont vers l'avant en reculant) : face nord du bloc sous soi, œil juste derrière le plan.
assertNull(a(new double[] {0.5, 66.62, -0.2}, CUBE, NORD, new double[] {0.5, 64.8, 0}, false, true));
// Début de casse sans impact, à 4 blocs.
assertNull(a(new double[] {0.5, 66.62, 5.0}, CUBE, SUD, null, false, true));
}
@Test
void anomalies() {
assertEquals("bloc-vide", a(new double[] {0.5, 66.62, 2}, CUBE, HAUT, new double[] {0.5, 65, 0.5}, true, false));
// Face du bas cliquée depuis au-dessus du bloc (à travers le bloc).
assertEquals("face-cachee", a(new double[] {0.5, 66.62, 2}, CUBE, BAS, new double[] {0.5, 64, 0.5}, false, true));
// Face ouest cliquée depuis l'est, à 2 blocs derrière le plan.
assertEquals("face-cachee", a(new double[] {3.0, 65.62, 0.5}, CUBE, OUEST, new double[] {0, 64.5, 0.5}, false, true));
// Impact au centre du bloc (vecteur forgé), face haute.
assertEquals("impact-hors-face", a(new double[] {0.5, 66.62, 2}, CUBE, HAUT, new double[] {0.5, 64.5, 0.5}, false, true));
// 5,2 blocs : au-delà de 4,5 + 0,5, en deçà de la limite vanilla (portée + 1).
assertEquals("hors-portee", a(new double[] {0.5, 64.5, 6.2}, CUBE, SUD, new double[] {0.5, 64.5, 1}, false, true));
}
@Test
void coordonneesTransformeesNonMesurees() {
// Au-delà de portée + 1, vanilla refuse le paquet : si l'événement arrive quand même, un mod (Sable) a
// transformé les coordonnées : rien n'est mesuré, même un bloc d'air.
assertNull(a(new double[] {5000, 100, 5000}, CUBE, BAS, new double[] {0.5, 64, 0.5}, true, true));
}
@Test
void margeDuDeplacement() {
// Œil 1 bloc derrière le plan : anomalie avec la marge seule, pas après un déplacement de 0,6 bloc.
double[] oeil = {1.0, 66.62, 0.5};
double[] impact = {0, 64.5, 0.5};
assertEquals(null, InteractionBloc.anomalie(oeil, CUBE, OUEST, impact, false, true, 4.5, 1.1));
assertEquals("face-cachee", InteractionBloc.anomalie(oeil, CUBE, OUEST, impact, false, true, 4.5, 0.5));
}
private double serie(Moteur m, EtatJoueur etat, int n, boolean air) {
double pts = 0;
for (int i = 0; i < n; i++) {
for (Verdict v : m.interactionBloc(joueur, i * 500L, etat, new double[] {0.5, 66.62, 2}, CUBE, HAUT,
new double[] {0.5, 65, 0.5}, air, true, 4.5, 0)) {
if (v.controle() == Controle.INTERACTION_BLOC) pts += v.points();
}
}
return pts;
}
@Test
void serieExigee() {
assertEquals(0, serie(new Moteur(cfg), EtatJoueur.normal(), 2, true), 1e-9);
assertTrue(serie(new Moteur(cfg), EtatJoueur.normal(), 3, true) > 0);
assertEquals(0, serie(new Moteur(cfg), EtatJoueur.normal(), 50, false), 1e-9);
}
@Test
void exemptions() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().pocheContraption(true).build()}) {
assertEquals(0, serie(new Moteur(cfg), e, 10, true), 1e-9, e.toString());
}
}
// --- Revues de sécurité (main secondaire, doublons) ---
private static final double[] OEIL = {0.5, 66.62, 2};
private static final double[] IMPACT = {0.5, 65, 0.5};
private List<Verdict> clic(Moteur m, long t, long cle, int main, int face, double[] impact, boolean air) {
return m.interactionBloc(joueur, t, cle, main, EtatJoueur.normal(), OEIL, CUBE, face, impact, air, true, 4.5, 0);
}
private static double pts(List<Verdict> v) {
return v.stream().filter(x -> x.controle() == Controle.INTERACTION_BLOC).mapToDouble(Verdict::points).sum();
}
@Test
void mainSecondaireSeuleMesuree() {
Moteur m = new Moteur(cfg);
double p = 0;
for (int i = 0; i < 3; i++) p += pts(clic(m, i * 500L, 100L + i, 1, HAUT, IMPACT, true));
assertTrue(p > 0, "3 clics forgés en main secondaire seule suffisent");
}
@Test
void doublonVanillaMainPuisSecondaireCompteUneFoisEtGardeLaDecision() {
Moteur m = new Moteur(cfg);
for (int i = 0; i < 2; i++) {
clic(m, i * 500L, 7L, 0, HAUT, IMPACT, true);
clic(m, i * 500L, 7L, 1, HAUT, IMPACT, true);
}
assertEquals(2, m.suivi(joueur).interactionBloc.dernierCompte(), "2 clics (4 événements) = 2 anomalies");
// 3e clic : la principale atteint la série ; la secondaire reprend exactement ses verdicts (même annulation).
List<Verdict> principale = clic(m, 1000L, 7L, 0, HAUT, IMPACT, true);
List<Verdict> secondaire = clic(m, 1000L, 7L, 1, HAUT, IMPACT, true);
assertTrue(pts(principale) > 0);
assertEquals(principale, secondaire, "un doublon ne se lit jamais comme autorisé");
assertEquals(3, m.suivi(joueur).interactionBloc.dernierCompte(), "non recompté");
}
@Test
void deuxiemeEvenementIdentiqueDeLaMemeMainEvalue() {
Moteur m = new Moteur(cfg);
double p = 0;
for (int k = 0; k < 3; k++) p += pts(clic(m, 500L, 7L, 0, HAUT, IMPACT, true)); // 3 fois la principale, même tick
assertTrue(p > 0, "les répétitions de la même main comptent");
// secondaire répétée : dédoublonnée une seule fois par tick
Moteur m2 = new Moteur(cfg);
clic(m2, 500L, 7L, 0, HAUT, IMPACT, true);
clic(m2, 500L, 7L, 1, HAUT, IMPACT, true);
clic(m2, 500L, 7L, 1, HAUT, IMPACT, true);
assertEquals(2, m2.suivi(joueur).interactionBloc.dernierCompte());
}
@Test
void secondaireAvecAutreFaceOuImpactEvaluee() {
Moteur m = new Moteur(cfg);
clic(m, 500L, 7L, 0, HAUT, IMPACT, false);
// même tick, même bloc, main secondaire mais face du bas vue d'en haut : vérifiée et comptée
clic(m, 500L, 7L, 1, BAS, new double[] {0.5, 64, 0.5}, false);
assertEquals(1, m.suivi(joueur).interactionBloc.dernierCompte());
clic(m, 600L, 7L, 0, HAUT, IMPACT, false);
clic(m, 600L, 7L, 1, HAUT, new double[] {0.5, 64.5, 0.5}, false); // impact forgé au centre
assertEquals(2, m.suivi(joueur).interactionBloc.dernierCompte());
}
@Test
void rafaleSurLeMemeBlocDetectee() {
Moteur m = new Moteur(cfg);
double p = 0;
for (int k = 0; k < 10; k++) {
p += pts(clic(m, 500L, 7L, 0, HAUT, IMPACT, true));
p += pts(clic(m, 500L, 7L, 1, HAUT, IMPACT, true));
}
assertTrue(p > 0, "rafale de 20 événements dans un tick sur un bloc d'air");
}
}
+219
Voir le fichier
@@ -0,0 +1,219 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.6, P2.6 : inventaire (ChestStealer, InventoryMove, InvCleaner / AutoArmor). */
class InventaireP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private static EtatJoueur ping(int ms) {
return EtatJoueur.builder().pingMs(ms).build();
}
private static int compter(List<Verdict> v) {
int n = 0;
for (Verdict x : v) if (x.controle() == Controle.INVENTAIRE && x.points() > 0) n++;
return n;
}
/** Ouvre un coffre au tick 100 et prend n objets différents à partir de {@code debut}, un tous les {@code pas} ticks. */
private int session(Moteur m, EtatJoueur e, long debut, int pas, int n, boolean memeObjet) {
m.ouvrirConteneur(joueur, 100);
int verdicts = 0;
for (int i = 0; i < n; i++) {
long t = debut + (long) i * pas;
verdicts += compter(m.clicConteneur(joueur, t * 50L, t, e, true, true, Inventaire.Clic.PRISE, true,
memeObjet ? 7 : 10 + i));
}
return verdicts;
}
@Test
void observeParDefautEtSeuilsPropres() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.INVENTAIRE));
assertEquals(Controle.INVENTAIRE, Controle.parse("inventaire"));
cfg.inventaireSeuilSetback = 4;
assertEquals(Sanction.SETBACK, Paliers.palier(5, cfg, Controle.INVENTAIRE));
assertEquals(Sanction.ALERTE, Paliers.palier(5, cfg, Controle.TOWER)); // les autres gardent le seuil global
}
@Test
void humainRapideNonVu() {
// Réaction 300 ms (6 ticks, ping 50), puis un shift-clic tous les 2 ticks : très rapide mais humain.
assertEquals(0, session(new Moteur(cfg), ping(50), 106, 2, 27, false));
}
@Test
void doubleClicShiftVanillaNonVu() {
// Shift + double-clic : toutes les cases du même objet dans le même tick, dès 2 ticks après l'ouverture.
assertEquals(0, session(new Moteur(cfg), ping(0), 102, 0, 27, true));
}
@Test
void mouseTweaksApresReactionHumaineNonVu() {
// Glisser shift sur 9 cases en 2 ticks, mais 400 ms après l'ouverture : la réaction humaine sauve le joueur.
Moteur m = new Moteur(cfg);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int i = 0; i < 9; i++) {
long t = 108 + i / 5;
n += compter(m.clicConteneur(joueur, t * 50L, t, ping(0), true, true, Inventaire.Clic.PRISE, true, 10 + i));
}
assertEquals(0, n);
}
@Test
void pingEleveHonneteNonVu() {
// Ping 400 ms (plafonné à 300) : 650 ms après l'ouverture, réaction calculée 350 ms.
assertEquals(0, session(new Moteur(cfg), ping(400), 113, 1, 27, false));
}
@Test
void chestStealerVuEtChaquePriseSuivanteCompte() {
// Prises dès le tick suivant l'ouverture (ping 50 retiré : réaction 0), une par tick.
int v = session(new Moteur(cfg), ping(50), 101, 1, 27, false);
assertEquals(27 - cfg.inventairePrisesMin + 1, v);
}
@Test
void stealerQuiGonfleSonPingVuQuandMeme() {
// Ping déclaré 2000 ms : plafonné à 300, la réaction reste nulle.
assertTrue(session(new Moteur(cfg), ping(2000), 101, 1, 20, false) > 0);
}
@Test
void stealerLentNonVuLimiteConnue() {
// Délai aléatoire de 150 ms : intervalle moyen 3 ticks, pas vu (limite documentée).
assertEquals(0, session(new Moteur(cfg), ping(0), 101, 3, 27, false));
}
@Test
void creatifSpectateurEtGelServeurExemptes() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().ticksDepuisGel(5).build()}) {
assertEquals(0, session(new Moteur(cfg), e, 101, 1, 27, false), e.toString());
}
}
@Test
void lagServeurAssouplit() {
// TPS bas : paquets regroupés. Réaction exigée et intervalle maximal divisés par facteurLag (1,5) : réaction
// 66 ms au lieu de 100, intervalle 1,0 tick au lieu de 1,5. Première prise au tick 102 (100 ms) : jamais vue.
EtatJoueur lag = EtatJoueur.builder().tps(15).build();
assertTrue(session(new Moteur(cfg), EtatJoueur.normal(), 101, 1, 20, false) > 0);
assertEquals(0, session(new Moteur(cfg), lag, 102, 1, 20, false));
// Prises groupées 2 par tick (intervalle moyen 0,5) dès l'ouverture : vues même sous lag.
Moteur m = new Moteur(cfg);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int i = 0; i < 20; i++) {
long t = 100 + i / 2;
n += compter(m.clicConteneur(joueur, t * 50L, t, lag, true, true, Inventaire.Clic.PRISE, true, 10 + i));
}
assertTrue(n > 0);
}
@Test
void rotationEcranOuvertApresGraceVue() {
Moteur m = new Moteur(cfg);
m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int t = 101; t < 140; t++) {
n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 10));
}
// grâce 10 ticks : rotations comptées à partir du tick 111, la 3e et les suivantes donnent des points
assertEquals(139 - 111 + 1 - (cfg.inventaireRotationsMin - 1), n);
}
@Test
void rotationPendantLaGraceOuSansConteneurNonVue() {
Moteur m = new Moteur(cfg);
m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0);
m.ouvrirConteneur(joueur, 100);
int n = 0;
// le client n'a pas encore reçu l'écran (aller-retour) : il tourne encore
for (int t = 101; t <= 110; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 0));
m.fermerConteneur(joueur);
for (int t = 111; t < 200; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 0));
assertEquals(0, n);
}
@Test
void rotationEnVehiculeOuTeleportNonVue() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().ticksDepuisTeleport(0).build(), EtatJoueur.builder().elytres(true).build()}) {
Moteur m = new Moteur(cfg);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int t = 101; t < 160; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, e, t * 3f, 0));
assertEquals(0, n, e.toString());
}
}
@Test
void pingEleveAllongeLaGrace() {
Moteur m = new Moteur(cfg);
EtatJoueur e = ping(500); // grâce 10 + 10 ticks
m.regardInventaire(joueur, 0, 90, e, 0, 0);
m.ouvrirConteneur(joueur, 100);
int n = 0;
for (int t = 101; t <= 120; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, e, t * 3f, 0));
assertEquals(0, n);
}
@Test
void invCleanerPendantRotationVu() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int t = 100; t < 120; t++) {
m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 5f, 0);
n += compter(m.clicConteneur(joueur, t * 50L, t, EtatJoueur.normal(), true, false, Inventaire.Clic.PRISE, false, 3));
}
assertTrue(n > 10);
}
@Test
void clicInventaireTeteImmobileNonVu() {
Moteur m = new Moteur(cfg);
m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0);
int n = 0;
for (int t = 100; t < 160; t++) {
m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), 0, 0);
n += compter(m.clicConteneur(joueur, t * 50L, t, EtatJoueur.normal(), true, false, Inventaire.Clic.PRISE, false, 3));
}
assertEquals(0, n);
}
@Test
void clicsSurConteneurFermeJournalSeulementEnSerie() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 3; i++) n += m.clicConteneur(joueur, 1000 + i, 20, EtatJoueur.normal(), false, false,
Inventaire.Clic.PRISE, false, 0).size();
assertEquals(0, n);
for (int i = 3; i < 12; i++) n += m.clicConteneur(joueur, 1000 + i, 20, EtatJoueur.normal(), false, false,
Inventaire.Clic.PRISE, false, 0).size();
assertTrue(n > 0);
assertTrue(m.suivi(joueur).vl.valeur(Controle.INVENTAIRE, 1012) < cfg.seuilAlerte);
}
@Test
void etatOublieALaDeconnexion() {
Moteur m = new Moteur(cfg);
session(m, ping(0), 101, 1, 10, false);
Suivi avant = m.suivi(joueur);
assertTrue(avant.inventaire.sessionSuspecte());
m.retirer(joueur);
assertNotSame(avant, m.suivi(joueur));
assertTrue(!m.suivi(joueur).inventaire.sessionSuspecte() && !m.suivi(joueur).inventaire.ouvert());
}
}
+68
Voir le fichier
@@ -0,0 +1,68 @@
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 java.util.function.IntFunction;
import org.junit.jupiter.api.Test;
/** 0.5, P2.11 : jesus (au sol déclaré sur un fluide). */
class JesusP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** Marche à 0,2 bloc/tick, au sol selon le client ou non, sol serveur faux (fluide), milieu spécial (dans l'eau). */
private static EtatMouvement surEau(boolean solClient, double dy) {
return new EtatMouvement(0.2, dy, 1, solClient, false, false, false, false, 0, 0, true, false);
}
private double total(EtatJoueur etat, int n, IntFunction<EtatMouvement> m, FaitsMouvement f) {
Moteur mo = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < n; i++) {
for (Verdict v : mo.mouvementP2(joueur, i * 50L, etat, m.apply(i), f)) {
if (v.controle() == Controle.JESUS) pts += v.points();
}
}
return pts;
}
private static FaitsMouvement eau() {
return new FaitsMouvement().fluide(true, false);
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.JESUS));
assertEquals(Controle.JESUS, Controle.parse("jesus"));
}
@Test
void marcheSurLEauVue() {
assertTrue(total(EtatJoueur.normal(), 10, i -> surEau(true, 0), eau()) > 0);
assertEquals(0, total(EtatJoueur.normal(), 9, i -> surEau(true, 0), eau()), 1e-9);
}
@Test
void nageHonneteJamaisVue() {
// Nage en surface : jamais au sol selon le client vanilla (un fluide n'a pas de collision).
assertEquals(0, total(EtatJoueur.normal(), 200, i -> surEau(false, i % 2 == 0 ? 0.02 : -0.02), eau()), 1e-9);
// Debout au fond (sol serveur vrai), sur un nénuphar ou de la glace : sol serveur, rien.
assertEquals(0, total(EtatJoueur.normal(), 200,
i -> new EtatMouvement(0.1, 0, 1, true, true, false, false, false, 0, 0, true, false), eau()), 1e-9);
}
@Test
void bateauOuVaisseauSousLesPiedsExempte() {
assertEquals(0, total(EtatJoueur.normal(), 50, i -> surEau(true, 0), new FaitsMouvement().fluide(true, true)), 1e-9);
assertEquals(0, total(EtatJoueur.builder().pocheContraption(true).build(), 50, i -> surEau(true, 0), eau()), 1e-9);
assertEquals(0, total(EtatJoueur.builder().enVehicule(true).build(), 50, i -> surEau(true, 0), eau()), 1e-9);
}
@Test
void sansFluideRien() {
assertEquals(0, total(EtatJoueur.normal(), 50, i -> surEau(true, 0), new FaitsMouvement()), 1e-9);
}
}
+100
Voir le fichier
@@ -0,0 +1,100 @@
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 java.util.function.IntFunction;
import org.junit.jupiter.api.Test;
/** 0.5, P2.1 : no-slow (vitesse gardée pendant un usage d'objet). */
class NoSlowP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** Paquet d'un tick au sol plat, en utilisant un objet, à la vitesse dxz. */
private static EtatMouvement usage(double dxz, int vitesse) {
return new EtatMouvement(dxz, 0, 1, true, true, true, false, true, vitesse, 0, false, false);
}
private double total(Moteur m, EtatJoueur etat, int paquets, IntFunction<EtatMouvement> f, int graceUsage) {
double pts = 0;
for (int i = 0; i < paquets; i++) {
FaitsMouvement faits = new FaitsMouvement().ticksUsage(i + graceUsage);
for (Verdict v : m.mouvementP2(joueur, (i + 1) * 50L, etat, f.apply(i), faits)) {
if (v.controle() == Controle.NO_SLOW) pts += v.points();
}
}
return pts;
}
@Test
void observeParDefautEtFiabiliteFaible() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.NO_SLOW));
assertEquals(Controle.NO_SLOW, Controle.parse("no-slow"));
assertEquals(2, Controle.NO_SLOW.fiabilite());
}
@Test
void courseEnMangeantVue() {
// 0,28 bloc/tick (course vanilla) en mangeant, 20 paquets : au moins une infraction.
assertTrue(total(new Moteur(cfg), EtatJoueur.normal(), 20, i -> usage(0.28, 0), 0) > 0);
}
@Test
void joueurHonneteJamaisVu() {
// Vanilla : ×0,2, sprint gardé = ~0,056 bloc/tick ; avec Vitesse II, ~0,08.
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 200, i -> usage(0.06, 0), 0), 1e-9);
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 200, i -> usage(0.08, 2), 0), 1e-9);
}
@Test
void elanDuDebutDUsageIgnore() {
// Les 3 premiers ticks d'usage (élan de la course) ne comptent pas : 3 + 9 paquets rapides = pas encore 10.
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 12, i -> usage(0.28, 0), -2), 1e-9);
}
@Test
void sautGlaceMilieuEtPaquetsGroupesNeComptentPas() {
// Saut (dy != 0), glace, eau, plusieurs ticks entre deux paquets : rien.
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
i -> new EtatMouvement(0.28, i % 2 == 0 ? 0.42 : 0, 1, false, i % 2 != 0, true, false, true, 0, 0, false, false), 0), 1e-9);
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, true, 0, 0, false, true), 0), 1e-9);
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, true, 0, 0, true, false), 0), 1e-9);
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
i -> new EtatMouvement(0.56, 0, 2, true, true, true, false, true, 0, 0, false, false), 0), 1e-9);
}
@Test
void sansUsageDObjetRien() {
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40,
i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, false, 0, 0, false, false), 0), 1e-9);
// usage inconnu (-1) : pas de mesure
Moteur m = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < 40; i++) {
for (Verdict v : m.mouvementP2(joueur, i * 50L, EtatJoueur.normal(), usage(0.28, 0), new FaitsMouvement())) pts += v.points();
}
assertEquals(0, pts, 1e-9);
}
@Test
void exemptions() {
for (EtatJoueur e : new EtatJoueur[] {
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(),
EtatJoueur.builder().enVehicule(true).build(), EtatJoueur.builder().pocheContraption(true).build(),
EtatJoueur.builder().ticksDepuisRecul(1).build(), EtatJoueur.builder().ticksDepuisGel(5).build(),
EtatJoueur.builder().connexionRecente(true).build()}) {
assertEquals(0, total(new Moteur(cfg), e, 40, i -> usage(0.28, 0), 0), 1e-9, e.toString());
}
}
@Test
void offNeMesureRien() {
cfg.mode(Controle.NO_SLOW, Mode.OFF);
assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, i -> usage(0.28, 0), 0), 1e-9);
}
}
+634
Voir le fichier
@@ -0,0 +1,634 @@
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.BeforeEach;
import org.junit.jupiter.api.Test;
/** 0.4.0 : contrôles elytres (Elytra Hack), velocite (Anti Knockback / Anti Push), auto-totem, et bateau. */
class NouveauxControlesTest {
private GardeConfig cfg;
private Moteur moteur;
private final UUID j = UUID.randomUUID();
private long now;
@BeforeEach
void init() {
cfg = new GardeConfig();
moteur = new Moteur(cfg);
now = 1_000_000;
}
@Test
void modesParDefautTousEnObserve() {
for (Controle c : List.of(Controle.ELYTRES, Controle.VELOCITE, Controle.AUTO_TOTEM)) {
assertEquals(Mode.OBSERVE, cfg.mode(c), c.id());
assertEquals(c == Controle.AUTO_TOTEM ? 0 : 2, c.fiabilite(), c.id() + " : plafond 50 (auto-totem, 0.4.1) ou 15");
}
}
// --- Elytres ---
private double plane(EtatJoueur etat, double dxz, double dy, int ticks) {
now += 50L * ticks;
EtatMouvement m = new EtatMouvement(dxz, dy, ticks, false, false, false, false, false, 0, 0, false, false);
return moteur.mouvement(j, now, etat, m).stream().filter(v -> v.controle() == Controle.ELYTRES)
.mapToDouble(Verdict::points).sum();
}
private static EtatJoueur enPlane() {
return EtatJoueur.builder().elytres(true).build();
}
@Test
void elytresMonteeSansPerteDeVitesseEstVue_VanillaFly() {
double total = 0;
for (int i = 0; i < 40; i++) total += plane(enPlane(), 1.0, 0.4, 1); // monte à vitesse constante
assertTrue(total > 0);
assertEquals(Mode.OBSERVE, moteur.config().mode(Controle.ELYTRES));
}
@Test
void elytresPlaneImmobileEstVu() {
double total = 0;
for (int i = 0; i < 40; i++) total += plane(enPlane(), 0.02, 0.0, 1);
assertTrue(total > 0, "immobile en plané sans chuter : impossible en vanilla");
}
@Test
void elytresVraiPlaneEtMonteeAvecPerteDeVitesseSontNormaux() {
double total = 0;
double v = 2.0;
for (int i = 0; i < 25; i++) { // piqué puis cabré : la vitesse se transforme en altitude
total += plane(enPlane(), v, -0.5, 1);
v *= 0.99;
}
for (int i = 0; i < 30; i++) {
total += plane(enPlane(), v, 0.35, 1);
v *= 0.93; // la montée coûte de la vitesse
}
for (int i = 0; i < 40; i++) total += plane(enPlane(), 1.0, -0.2, 1); // plané descendant
assertEquals(0, total);
}
@Test
void elytresFuseeQuiAccelereVraimentSuspendLesCompteursSansLesEffacer() {
double total = 0;
for (int i = 0; i < 15; i++) total += plane(enPlane(), 1.0, 0.4, 1); // 15 ticks de montée suspecte
assertEquals(0, total, "sous les 20 ticks");
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
double v = 1.0;
for (int i = 0; i < 60; i++) { // la fusée accélère réellement : 1,0 -> 1,6
v = Math.min(1.6, v + 0.05);
total += plane(fusee, v, 0.4, 1);
}
assertEquals(0, total, "pendant la grâce rien ne compte");
// grâce finie : les 15 ticks d'avant sont conservés, 6 ticks de plus suffisent (> 20)
double apres = 0;
for (int i = 0; i < 6; i++) apres += plane(enPlane(), 1.6, 0.4, 1);
assertTrue(apres > 0, "compteurs conservés, pas remis à zéro par la fusée");
}
@Test
void elytresFuseeQuiNAcceleratPasEstRevoqueeApres10Ticks() {
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // vitesse d'avant la fusée : 1,0
double total = 0;
for (int i = 0; i < 60; i++) total += plane(fusee, 1.0, 0.4, 1); // vitesse constante : la fusée ne pousse pas
assertTrue(total > 0, "grâce révoquée, la montée à vitesse constante est vue malgré le drapeau");
}
@Test
void elytresFuseeDejaALaVitesseMaximaleGardeLaGrace() {
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
double total = 0;
for (int i = 0; i < 40; i++) total += plane(fusee, 1.8, 0.3, 1);
assertEquals(0, total);
}
@Test
void elytresAutreExemptionOuMilieuSpecialEcarteLeControle() {
EtatJoueur recul = EtatJoueur.builder().elytres(true).ticksDepuisRecul(0).build();
double total = 0;
for (int i = 0; i < 60; i++) total += plane(recul, 1.0, 0.4, 1);
assertEquals(0, total, "plané + recul : plusieurs raisons, contrôle écarté");
for (int i = 0; i < 60; i++) {
now += 50;
EtatMouvement milieu = new EtatMouvement(1.0, 0.4, 1, false, false, false, false, false, 0, 0, true, false);
assertTrue(moteur.mouvement(j, now, enPlane(), milieu).isEmpty(), "courant d'air / bulles / eau");
}
}
@Test
void elytresPaquetsADeuxTicksEtRafalesNeSontPasMesures() {
double total = 0;
for (int i = 0; i < 40; i++) total += plane(enPlane(), 1.0, 0.4, 0); // 0 tick : neutre
assertEquals(0, total);
for (int i = 0; i < 40; i++) total += plane(enPlane(), 3.0, 0.8, 5); // trous : neutre aussi
assertEquals(0, total);
}
@Test
void elytresDesactiveParLeMode() {
cfg.mode(Controle.ELYTRES, Mode.OFF);
double total = 0;
for (int i = 0; i < 60; i++) total += plane(enPlane(), 1.0, 0.4, 1);
assertEquals(0, total);
}
@Test
void elytresNeSanctionnePasEnObserve() {
for (int i = 0; i < 200; i++) {
now += 50;
EtatMouvement m = new EtatMouvement(1.0, 0.4, 1, false, false, false, false, false, 0, 0, false, false);
for (Verdict v : moteur.mouvement(j, now, enPlane(), m)) {
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString());
}
}
}
// --- Velocite ---
/** Recul de force 0,4 vers +x ; le joueur se déplace de dx par tick pendant n ticks. */
private double recul(double force, double dxParTick, int n, EtatJoueur etat, boolean milieu) {
now += 50;
moteur.suivi(j);
moteur.reculApplique(j, now, 1, 0, force, true);
double pts = 0;
for (int i = 0; i < n; i++) {
now += 50;
pts += moteur.mesureRecul(j, now, etat, dxParTick, 0, milieu, (x, z) -> false).stream().mapToDouble(Verdict::points).sum();
}
return pts;
}
@Test
void velociteReculVanillaNEstJamaisUneInfraction() {
for (int k = 0; k < 10; k++) {
// 0,4 de force : 0,4 puis 0,364... environ 1,8 bloc en 6 ticks
assertEquals(0, recul(0.4, 0.3, 7, EtatJoueur.normal(), false));
}
}
@Test
void velociteAntiKnockbackEstVuEnSerieSeulement() {
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false), "1er recul absent : pas de série");
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false), "2e : pas encore");
assertTrue(recul(0.4, 0.0, 7, EtatJoueur.normal(), false) > 0, "3e recul absent sur 3 : infraction");
}
@Test
void velociteJoueurContreUnMurFrappeSouventNAJamaisDeVerdict() {
// griefing : un tiers coince le joueur contre un mur puis le frappe ; l'adaptateur passe libre = false
for (int k = 0; k < 12; k++) {
now += 50;
moteur.suivi(j);
moteur.reculApplique(j, now, 1, 0, 0.4, false);
for (int i = 0; i < 7; i++) {
now += 50;
assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false).isEmpty());
}
}
}
@Test
void velociteJoueurDansUnTrouDUnBlocFrappeNAJamaisDeVerdict() {
for (int k = 0; k < 12; k++) {
now += 50;
moteur.suivi(j);
moteur.reculApplique(j, now, 0, 1, 0.9, false);
for (int i = 0; i < 7; i++) {
now += 50;
assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false).isEmpty());
}
}
}
@Test
void velociteJoueurLibreSansReculDonneUnVerdict() {
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
assertTrue(recul(0.4, 0.0, 7, EtatJoueur.normal(), false) > 0);
}
/** Trois reculs de force 0,4 vers +x, joueur immobile ; renvoie les points du dernier, avec un prédicat de blocage. */
private double troisReculs(java.util.function.BiPredicate<Double, Double> bloque, java.util.function.IntPredicate tickBloque) {
double derniers = 0;
for (int k = 0; k < 3; k++) {
now += 50;
moteur.suivi(j);
moteur.reculApplique(j, now, 1, 0, 0.4, true);
derniers = 0;
int[] tick = {0};
for (int i = 0; i < 7; i++) {
now += 50;
final int t = tick[0]++;
derniers += moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false,
(x, z) -> bloque.test(x, z) && tickBloque.test(t)).stream().mapToDouble(Verdict::points).sum();
}
}
return derniers;
}
@Test
void velociteMurLateralPerpendiculaireAuReculGardeLaMesure() {
// le mur est sur l'axe z ; le recul part vers +x : le prédicat directionnel ne le voit pas
assertTrue(troisReculs((x, z) -> z != 0, t -> true) > 0, "mesure gardée, verdict à la série");
}
@Test
void velociteMurDansLaDirectionDuReculAbandonneLaMesure() {
assertEquals(0, troisReculs((x, z) -> x > 0, t -> true));
for (int k = 0; k < 6; k++) assertEquals(0, troisReculs((x, z) -> x > 0, t -> true));
}
@Test
void velociteUnSeulTickDeCollisionNAnnulePasLaFenetre() {
assertTrue(troisReculs((x, z) -> true, t -> t == 3) > 0, "un tick isolé : mesure gardée");
}
@Test
void velociteGelDuServeurOuTpsBasAbandonneLaMesure() {
EtatJoueur gel = EtatJoueur.builder().ticksDepuisGel(10).build();
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, gel, false), "juste après un gel du serveur");
EtatJoueur lag = EtatJoueur.builder().tps(10.0).build();
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, lag, false), "serveur qui rame");
}
@Test
void elytresPicIsoleSuiviDUneVitessePlateRetireLaGrace() {
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // vitesse avant la fusée : 1,0
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
moteur.nouvelleFusee(j);
double total = 0;
for (int i = 0; i < 60; i++) {
double v = i == 2 ? 3.0 : 1.0; // un seul pic, puis plat
total += plane(fusee, v, 0.4, 1);
}
assertTrue(total > 0, "la médiane reste à 1,0 : pas de gain réel, grâce retirée");
}
@Test
void elytresDixFuseesEnchaineesSansGainReelSontRetirees() {
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // vitesse d'avant : 1,0
double total = 0;
for (int f = 0; f < 10; f++) {
moteur.nouvelleFusee(j); // ne remet rien à zéro
for (int i = 0; i < 6; i++) total += plane(fusee, 1.0, 0.4, 1); // le drapeau ne tombe jamais
}
assertTrue(total > 0, "60 ticks de grâce cumulés sans gain : le test de gain est évalué et retire la grâce");
}
@Test
void elytresGraceRefuseeNeSeReouvrePasAvantUnePause() {
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1);
for (int i = 0; i < 12; i++) plane(fusee, 1.0, 0.1, 1); // fenêtre sans gain : refusée
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1); // le drapeau tombe 5 ticks seulement
double total = 0;
for (int i = 0; i < 40; i++) total += plane(fusee, 1.0, 0.4, 1); // nouvelle fusée aussitôt : pas de grâce
assertTrue(total > 0, "nouvelle fenêtre refusée tant que la pause n'est pas écoulée");
// après une vraie pause, une fusée qui accélère est de nouveau acceptée
for (int i = 0; i < 50; i++) plane(enPlane(), 1.0, -0.1, 1);
double v = 1.0, apres = 0;
for (int i = 0; i < 12; i++) apres += plane(fusee, v += 0.06, 0.4, 1);
assertEquals(0, apres);
}
@Test
void elytresAtterrissagePuisDecollageAvecFuseePasDeVieilleReference() {
// vitesse élevée en plané, puis atterrissage (sol serveur) : la référence est effacée
for (int i = 0; i < 10; i++) plane(enPlane(), 2.5, -0.1, 1);
now += 50;
moteur.mouvement(j, now, EtatJoueur.normal(), new EtatMouvement(0, 0, 1, true, true, false, false, false, 0, 0, false, false));
// décollage lent avec fusée : sans vieille référence de 2,5, un vrai gain (0,6 -> 1,2) garde la grâce
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
double total = 0;
double v = 0.6;
for (int i = 0; i < 40; i++) total += plane(fusee, v = Math.min(1.5, v + 0.05), 0.4, 1);
assertEquals(0, total, "gain réel mesuré contre une référence inconnue, pas contre l'ancienne vitesse de 2,5");
}
@Test
void velociteEtAutoTotemJamaisDeSanctionEnObserve() { // 0.4.2 : en ENFORCE, voir Sanctions042Test
cfg.mode(Controle.VELOCITE, Mode.OBSERVE);
cfg.mode(Controle.AUTO_TOTEM, Mode.OBSERVE);
boolean vu = false;
for (int k = 0; k < 40; k++) {
now += 50;
moteur.suivi(j);
moteur.reculApplique(j, now, 1, 0, 0.4, true);
for (int i = 0; i < 7; i++) {
now += 50;
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
vu = true;
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString());
}
}
}
assertTrue(vu);
boolean totemVu = false;
for (int k = 0; k < 30; k++) {
moteur.totemEclate(j, now += 1000, false);
for (Verdict v : moteur.totemEnMain(j, now += 50, EtatJoueur.normal(), true)) {
totemVu = true;
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), v.toString());
}
}
assertTrue(totemVu);
}
@Test
void velociteUnMurOuUnContreIsoleNeSuffitPas() {
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false)); // contre un mur
assertEquals(0, recul(0.4, 0.3, 7, EtatJoueur.normal(), false)); // recul normal
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false)); // contre un mur encore
assertEquals(0, recul(0.4, 0.3, 7, EtatJoueur.normal(), false));
}
@Test
void velociteTraceReelleDElytresHonnetesSansInfractionElytres() throws Exception {
// trace du 15/10 : plané honnête (fusées comprises, non marquées dans la trace : on ne vérifie que la montée)
List<String> lignes = java.nio.file.Files.readAllLines(java.nio.file.Path.of(
NouveauxControlesTest.class.getResource("/traces/elytres-2026-10-15.jsonl").toURI()));
Rejeu.Resume r = Rejeu.rejouer(lignes, new GardeConfig());
System.out.println("ELYTRES-HONNETE infractions=" + r.infractions() + " exemples=" + r.exemples());
assertTrue(r.mouvements() > 500);
}
@Test
void velociteJoueurQuiContreEnMarchantEnArriereReculeEncore() {
// marche à 0,22 bloc par tick dans le sens opposé : recul net 0,4 + ... > 15 % du recul attendu
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.9, 0.25, 7, EtatJoueur.normal(), false));
}
@Test
void velociteExemptionsEtMilieux() {
List<EtatJoueur> etats = List.of(
EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().spectateur(true).build(),
EtatJoueur.builder().peutVoler(true).build(),
EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().riptide(true).build(),
EtatJoueur.builder().pocheContraption(true).build(),
EtatJoueur.builder().ticksDepuisTeleport(0).build());
for (EtatJoueur e : etats) {
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, e, false), e.toString());
}
for (int k = 0; k < 6; k++) assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), true), "eau, échelle…");
}
@Test
void velociteDeuxReculsDansLaFenetreOuForceNegligeableAnnulentLaMesure() {
for (int k = 0; k < 5; k++) {
now += 50;
moteur.reculApplique(j, now, 1, 0, 0.4, true);
moteur.reculApplique(j, now + 50, 1, 0, 0.4, true); // second coup pendant la fenêtre
for (int i = 0; i < 7; i++) {
now += 50;
assertTrue(moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false).isEmpty());
}
}
for (int k = 0; k < 5; k++) assertEquals(0, recul(0.05, 0.0, 7, EtatJoueur.normal(), false), "force < 0,15");
}
@Test
void velociteAnciennesMesuresExpirent() {
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
recul(0.4, 0.0, 7, EtatJoueur.normal(), false);
now += Velocite.VALIDITE_MS + 1000;
assertEquals(0, recul(0.4, 0.0, 7, EtatJoueur.normal(), false), "les deux premiers ont plus de 2 minutes");
}
// --- Auto-totem ---
private double totem(long delaiMs, int ping, boolean reserve) {
Moteur m = new Moteur(cfg);
UUID id = UUID.randomUUID();
m.suivi(id);
long t = 5_000_000;
m.totemEclate(id, t, reserve);
EtatJoueur e = EtatJoueur.builder().pingMs(ping).build();
double pts = 0;
for (long d = 50; d <= delaiMs + 200; d += 50) {
boolean enMain = d >= delaiMs;
pts += m.totemEnMain(id, t + d, e, enMain).stream().mapToDouble(Verdict::points).sum();
}
return pts;
}
@Test
void autoTotemRemisInstantanementEstVu() {
assertTrue(totem(50, 30, false) > 0);
assertTrue(totem(100, 30, false) > 0, "100 ms < 150 + 30");
}
@Test
void autoTotemDelaiHumainNormal() {
assertEquals(0, totem(300, 30, false));
assertEquals(0, totem(250, 50, false));
assertEquals(0, totem(2000, 30, false), "totem remis bien plus tard");
}
@Test
void autoTotemLePingNEntreQueBorne() {
assertEquals(0, totem(250, 100, false), "250 >= 150 + 100");
// ping annoncé de 5 s : seulement 200 ms de marge au plus (150 + 200 = 350)
assertTrue(totem(300, 5000, false) > 0);
assertEquals(0, totem(400, 5000, false));
}
@Test
void autoTotemTotemDeReserveEnMainAnnuleLaMesure() {
assertEquals(0, totem(50, 30, true));
}
@Test
void autoTotemAucunTotemRemisOuTropTardNeCompteRien() {
Moteur m = new Moteur(cfg);
UUID id = UUID.randomUUID();
m.suivi(id);
m.totemEclate(id, 1000, false);
EtatJoueur e = EtatJoueur.normal();
assertTrue(m.totemEnMain(id, 1050, e, false).isEmpty());
assertTrue(m.totemEnMain(id, 1000 + AutoTotem.EXPIRATION_MS + 50, e, true).isEmpty(), "mesure expirée");
// un totem ramassé bien après, sans nouvel éclatement : rien
assertTrue(m.totemEnMain(id, 1000 + AutoTotem.EXPIRATION_MS + 100, e, true).isEmpty());
}
@Test
void autoTotemMemeTickQueLEclatementNeCompteRien() {
Moteur m = new Moteur(cfg);
UUID id = UUID.randomUUID();
m.suivi(id);
m.totemEclate(id, 1000, false);
assertTrue(m.totemEnMain(id, 1000, EtatJoueur.normal(), true).isEmpty(), "totem encore compté dans la main");
}
@Test
void autoTotemOffEtObserve() {
cfg.mode(Controle.AUTO_TOTEM, Mode.OFF);
assertEquals(0, totem(50, 30, false));
}
// --- Bateau (Boat Hack : friction 0,99) ---
private static EtatVehicule bateau(double dxz, boolean glace) {
return new EtatVehicule(EtatVehicule.Type.BATEAU, dxz, 0, 1, false, true, glace, 0, false);
}
@Test
void bateauVanillaSurEauNEstJamaisVu() {
VehiculeMouvement v = new VehiculeMouvement();
double pts = 0;
for (int i = 0; i < 400; i++) pts += v.vitesse(bateau(0.40, false), 1.0, 1.5);
assertEquals(0, pts);
}
@Test
void bateauSurGlaceBleueVanillaNEstJamaisVu() {
VehiculeMouvement v = new VehiculeMouvement();
double pts = 0;
for (int i = 0; i < 400; i++) pts += v.vitesse(bateau(3.6, true), 1.0, 1.5);
assertEquals(0, pts);
}
@Test
void bateauFriction099EstVuEnQuelquesTicks() {
VehiculeMouvement v = new VehiculeMouvement();
int premier = -1;
for (int i = 0; i < 60 && premier < 0; i++) {
// boat hack : l'eau garde 99 % de la vitesse, l'accélération 0,04 par tick s'accumule vers 4 blocs par tick
double dxz = Math.min(4.0, 0.4 + 0.04 * i / 0.01 * 0.1);
if (v.vitesse(bateau(dxz, false), 1.0, 1.5) > 0) premier = i;
}
assertTrue(premier >= 0 && premier < 40, "premier point au tick " + premier);
}
@Test
void bateauLegerementTropRapideSeVoitAuBoutDeQuelquesSecondes() {
// 0,479 bloc/tick (valeur du journal du 23/10) : 0,03 au-dessus de la borne de 0,45, il faut du temps
VehiculeMouvement v = new VehiculeMouvement();
double pts = 0;
for (int i = 0; i < 20; i++) pts += v.vitesse(bateau(0.479, false), 1.0, 1.5);
assertEquals(0, pts, "20 ticks à 0,479 : 0,6 bloc d'excès cumulé, sous le seuil de 1,5");
for (int i = 0; i < 100; i++) pts += v.vitesse(bateau(0.479, false), 1.0, 1.5);
assertTrue(pts > 0, "soutenu 6 s, cela compte");
}
@Test
void controlesNouveauxPrisEnCompteParLeScoreDeSuspicion() {
// auto-totem seul ne rend jamais suspect (plafond 15) ; les trois ensemble restent sous 50
Suspicion s = new Suspicion(cfg);
s.noter(Controle.AUTO_TOTEM, 99, false, 0);
s.noter(Controle.VELOCITE, 99, false, 0);
s.noter(Controle.ELYTRES, 99, false, 0);
assertEquals(80, s.score(0), 1e-9); // 0.4.1 : auto-totem fiable (plafond 50) : 50 + 15 + 15
}
// --- 0.4.1 ---
@Test
void v041_autoTotemContinueApresPassageEnEnforceSansSanctionReelle() {
for (int k = 0; k < 5; k++) {
now += 5000;
moteur.totemEclate(j, now, false);
now += 50;
moteur.totemEnMain(j, now, EtatJoueur.normal(), true);
}
cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE); // ce que fait /garde mode ou /garde reload sur la meme config
int vus = 0;
for (int k = 0; k < 10; k++) {
now += 5000;
moteur.totemEclate(j, now, false);
now += 50;
for (Verdict v : moteur.totemEnMain(j, now, EtatJoueur.normal(), true)) {
if (v.controle() != Controle.AUTO_TOTEM) continue; // 0.5 (P2.7) : auto-totem-regulier à part
vus++;
assertEquals(Mode.ENFORCE, v.mode());
assertTrue(v.applicable() != Sanction.SETBACK, "0.4.2 : auto-totem n'a pas de setback (expulsion possible)");
}
}
assertEquals(10, vus, "les detections continuent en ENFORCE");
assertFalse(moteur.estExpulse(j));
}
@Test
void v041_velociteSixReculsAbsentsEspacesDe3sDepassentLeSetback() {
assertEquals(4.0, cfg.velocitePoints, 1e-9, "defaut 0.4.1");
double vlMax = 0;
for (int k = 0; k < 6; k++) {
now += 3000 - 50L * 8; // ~3 s entre deux coups
now += 50;
moteur.reculApplique(j, now, 1, 0, 0.4, true);
for (int i = 0; i < 7; i++) {
now += 50;
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
vlMax = Math.max(vlMax, v.vl());
}
}
}
assertTrue(vlMax > cfg.seuilSetback, "vl max " + vlMax + " doit depasser " + cfg.seuilSetback);
}
@Test
void v041_velocitePointsConfigurables() {
cfg.velocitePoints = 2.0; // comportement 0.4.0 : plafonne sous le setback
double vlMax = 0;
for (int k = 0; k < 6; k++) {
now += 2600;
moteur.reculApplique(j, now, 1, 0, 0.4, true);
for (int i = 0; i < 7; i++) {
now += 50;
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
vlMax = Math.max(vlMax, v.vl());
}
}
}
assertTrue(vlMax < cfg.seuilSetback, "2 points : " + vlMax);
}
@Test
void v041_elytresMonteeAvecFuseeJournalTotoche10SansInfraction() {
// journal reel : plane rapide (reference hors grace ~1,5), puis fusee en montee : dxz 1,30-1,52, dy 0,66-1,04
for (int i = 0; i < 10; i++) plane(enPlane(), 1.55, -0.2, 1);
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
double[][] journal = {{1.300, 1.039}, {1.520, 0.658}, {1.456, 0.807}};
double total = 0;
for (int i = 0; i < 45; i++) {
double[] p = journal[i % 3];
total += plane(fusee, p[0], p[1], 1);
}
assertEquals(0, total, 1e-9, "fusee reelle en montee : aucune infraction");
}
@Test
void v041_elytresVlNeMontePlusDe1Point5ParPaquet() {
double vlMax = 0;
for (int i = 0; i < 20; i++) plane(enPlane(), 1.0, 0.4, 1); // periode de montee suspecte
for (int i = 0; i < 20; i++) {
now += 50;
EtatMouvement m = new EtatMouvement(1.0, 0.4, 1, false, false, false, false, false, 0, 0, false, false);
for (Verdict v : moteur.mouvement(j, now, enPlane(), m)) vlMax = Math.max(vlMax, v.vl());
}
assertTrue(vlMax > 0, "VanillaFly toujours vu");
assertTrue(vlMax <= 3.0, "au plus 1,5 point par periode de " + cfg.elytresMonteeTicks + " ticks : " + vlMax);
}
@Test
void v041_elytresFuseeSansPousseeToujoursRevoquee() {
EtatJoueur fusee = EtatJoueur.builder().elytres(true).propulsionRecente(true).build();
for (int i = 0; i < 5; i++) plane(enPlane(), 1.0, -0.1, 1);
double total = 0;
for (int i = 0; i < 60; i++) total += plane(fusee, 1.0, 0.4, 1); // 3D 1,08 < 1,44 : pas une vraie fusee
assertTrue(total > 0);
}
}
+105
Voir le fichier
@@ -0,0 +1,105 @@
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.3 : nuker (blocs cassés dans un même tick serveur). */
class NukerP3Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** casses[i] blocs au tick 100 + i * pas. */
private double casser(Moteur m, EtatJoueur etat, int pas, int... casses) {
double pts = 0;
for (int i = 0; i < casses.length; i++) {
long t = 100 + (long) i * pas;
for (int k = 0; k < casses[i]; k++) {
for (Verdict v : m.casseNuker(joueur, t * 50L, t, etat)) {
if (v.controle() == Controle.NUKER) pts += v.points();
}
}
}
return pts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.NUKER));
assertEquals(Controle.NUKER, Controle.parse("nuker"));
assertEquals(2, Controle.NUKER.fiabilite());
}
@Test
void nukerDeVingtBlocsParTickVu() {
assertTrue(casser(new Moteur(cfg), EtatJoueur.normal(), 5, 20, 20, 20, 20) > 0);
}
@Test
void uneCasseParTickJamaisVue() {
int[] c = new int[400];
java.util.Arrays.fill(c, 1);
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 1, c), 1e-9);
}
@Test
void paquetsGroupesParLaGigueTolere() {
// Herbe fauchée au clic maintenu, ticks client groupés par deux ou trois : jamais au-delà du plafond.
int[] c = new int[300];
for (int i = 0; i < c.length; i++) c[i] = 1 + i % 3;
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 2, c), 1e-9);
}
@Test
void unSeulTickSuspectNeSuffitPas() {
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 5, 1, 1, 8, 1, 1, 1, 1), 1e-9);
}
@Test
void exemptions() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().pocheContraption(true).build(),
EtatJoueur.builder().ticksDepuisGel(3).build(), EtatJoueur.builder().tps(12).build()}) {
assertEquals(0, casser(new Moteur(cfg), e, 5, 20, 20, 20, 20, 20), 1e-9, e.toString());
}
}
/** Rafale de n casses au tick t : [points comptés, casses annulées]. */
private double[] rafale(Moteur m, long t, int n) {
double pts = 0;
int annulees = 0;
for (int k = 0; k < n; k++) {
for (Verdict v : m.casseNuker(joueur, t * 50L, t, EtatJoueur.normal())) pts += v.points();
if (m.nukerAnnulerCasse(joueur, t * 50L, t)) annulees++;
}
return new double[] {pts, annulees};
}
@Test
void enforceAnnuleToutesLesCassesExcedentairesDuTick() {
cfg.mode(Controle.NUKER, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
double[] r = null;
// Rafales de 30 casses par tick jusqu'au palier SETBACK (10 de VL, 2 points par tick suspect en série).
for (int i = 0; i < 12; i++) r = rafale(m, 100 + i * 5L, 30);
assertEquals(2.0, r[0], 1e-9, "une seule infraction comptée par tick");
assertEquals(30 - cfg.nukerBlocsParTickMax, r[1], 1e-9, "toutes les casses excédentaires annulées");
}
@Test
void observeNAnnuleRien() {
Moteur m = new Moteur(cfg);
double annulees = 0;
for (int i = 0; i < 12; i++) annulees += rafale(m, 100 + i * 5L, 30)[1];
assertEquals(0, annulees, 1e-9);
}
@Test
void desactive() {
cfg.mode(Controle.NUKER, Mode.OFF);
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 5, 20, 20, 20, 20), 1e-9);
}
}
+71
Voir le fichier
@@ -0,0 +1,71 @@
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 java.util.function.IntFunction;
import org.junit.jupiter.api.Test;
/** 0.5, P2.14 : omnisprint (sprint en reculant ou de côté). */
class OmnisprintP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private static final EtatMouvement COURSE = new EtatMouvement(0.28, 0, 1, true, true, true, false, false, 0, 0, false, false);
private double total(EtatJoueur etat, int n, EtatMouvement m, IntFunction<FaitsMouvement> f) {
Moteur mo = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < n; i++) {
for (Verdict v : mo.mouvementP2(joueur, i * 50L, etat, m, f.apply(i))) {
if (v.controle() == Controle.OMNISPRINT) pts += v.points();
}
}
return pts;
}
/** Regard vers +z (yaw 0) ; déplacement de 0,28 dans la direction d'angle donnée (degrés depuis +z vers −x). */
private static FaitsMouvement dep(double angleDeg) {
double r = Math.toRadians(angleDeg);
return new FaitsMouvement().direction(-Math.sin(r) * 0.28, Math.cos(r) * 0.28, 0f);
}
@Test
void angleCalcule() {
assertEquals(0, Omnisprint.angle(0, 1, 0f), 1e-6); // yaw 0 = regard vers +z
assertEquals(180, Omnisprint.angle(0, -1, 0f), 1e-6);
assertEquals(90, Omnisprint.angle(-1, 0, 0f), 1e-6);
assertEquals(0, Omnisprint.angle(-1, 0, 90f), 1e-6); // yaw 90 = regard vers −x
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.OMNISPRINT));
}
@Test
void sprintEnReculantVu() {
assertTrue(total(EtatJoueur.normal(), 10, COURSE, i -> dep(180)) > 0);
assertTrue(total(EtatJoueur.normal(), 10, COURSE, i -> dep(120)) > 0);
}
@Test
void sprintVanillaJamaisVu() {
assertEquals(0, total(EtatJoueur.normal(), 200, COURSE, i -> dep(0)), 1e-9);
assertEquals(0, total(EtatJoueur.normal(), 200, COURSE, i -> dep(45)), 1e-9); // avant + côté
// demi-tour de la souris : élan arrière 3 ticks seulement
assertEquals(0, total(EtatJoueur.normal(), 200, COURSE, i -> dep(i % 20 < 3 ? 180 : 0)), 1e-9);
}
@Test
void reculGlaceEtAirExemptes() {
assertEquals(0, total(EtatJoueur.builder().ticksDepuisRecul(2).build(), 30, COURSE, i -> dep(180)), 1e-9);
assertEquals(0, total(EtatJoueur.normal(), 30,
new EtatMouvement(0.28, 0, 1, true, true, true, false, false, 0, 0, false, true), i -> dep(180)), 1e-9);
assertEquals(0, total(EtatJoueur.normal(), 30,
new EtatMouvement(0.28, -0.1, 1, false, false, true, false, false, 0, 0, false, false), i -> dep(180)), 1e-9);
assertEquals(0, total(EtatJoueur.normal(), 30, COURSE, i -> new FaitsMouvement()), 1e-9, "direction inconnue");
}
}
+94
Voir le fichier
@@ -0,0 +1,94 @@
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.6, P3.5 : phase (positions refusées par vanilla dans un bloc solide, en série). */
class PhaseP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private int refus(Moteur m, long nowMs, EtatJoueur e, boolean dansBloc) {
int n = 0;
for (Verdict v : m.refusPhase(joueur, nowMs, e, dansBloc, 0.5)) if (v.controle() == Controle.PHASE && v.points() > 0) n++;
return n;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.PHASE));
assertEquals(Controle.PHASE, Controle.parse("phase"));
}
@Test
void porteQuiSeFermeQuelquesRefusNonVu() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 4; i++) n += refus(m, 1000 + i * 500L, EtatJoueur.normal(), true);
assertEquals(0, n);
}
@Test
void refusHorsBlocNonComptes() {
// « moved too quickly » à cause du lag : refus, mais la position déclarée est libre.
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 50; i++) n += refus(m, 1000 + i * 100L, EtatJoueur.normal(), false);
assertEquals(0, n);
}
@Test
void refusEspacesNonVus() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 20; i++) n += refus(m, i * 15_000L, EtatJoueur.normal(), true);
assertEquals(0, n);
}
@Test
void clientDePhaseVu() {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 20; i++) n += refus(m, 1000 + i * 100L, EtatJoueur.normal(), true);
assertEquals(20 - cfg.phaseSerieMin + 1, n);
}
@Test
void enforceMonteAuPalier() {
cfg.mode(Controle.PHASE, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
boolean setback = false;
for (int i = 0; i < 30; i++) {
for (Verdict v : m.refusPhase(joueur, 1000 + i * 100L, EtatJoueur.normal(), true, 1)) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true;
}
}
assertTrue(setback);
}
@Test
void exemptions() {
EtatJoueur[] etats = {EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(),
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().enVehicule(true).build(), EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build(), EtatJoueur.builder().tps(10).build()};
for (EtatJoueur e : etats) {
Moteur m = new Moteur(cfg);
int n = 0;
for (int i = 0; i < 20; i++) n += refus(m, 1000 + i * 100L, e, true);
assertEquals(0, n, e.toString());
}
}
@Test
void etatOublieALaDeconnexion() {
Moteur m = new Moteur(cfg);
for (int i = 0; i < 4; i++) refus(m, 1000 + i * 100L, EtatJoueur.normal(), true);
m.retirer(joueur);
assertEquals(0, refus(m, 1500, EtatJoueur.normal(), true));
}
}
+146
Voir le fichier
@@ -0,0 +1,146 @@
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;
/** 0.6.1 : correctifs de la revue de sécurité du 25/10 (M1 à M4), côté moteur. */
class Revue061Test {
private final UUID joueur = UUID.randomUUID();
private static Verdict v(Controle c, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
}
// --- M1 : un seul setback par tick ---
@Test
void M1_secondSetbackDuMemeTickReconnuEtNonCompte() {
Moteur m = new Moteur(new GardeConfig());
long t = 1000 * 50L;
assertFalse(m.setbackDejaApplique(joueur, t));
m.apresSetback(joueur, t, List.of(v(Controle.VOL, Sanction.SETBACK)));
assertTrue(m.setbackDejaApplique(joueur, t));
m.apresSetbackDuMemeTick(joueur, List.of(v(Controle.JESUS, Sanction.SETBACK)));
assertEquals(1, m.suivi(joueur).setbacksRecents(t, 60_000), "un seul compte pour l'escalade");
assertFalse(m.setbackDejaApplique(joueur, t + 50), "tick suivant : un nouveau setback est possible");
}
@Test
void M1_tricheurContinuEscaladeToujours() {
// Un setback par tick sur 4 ticks distincts : l'escalade compte bien 4 (la triche répétée reste sanctionnée).
Moteur m = new Moteur(new GardeConfig());
for (int i = 0; i < 4; i++) m.apresSetback(joueur, (1000 + i) * 50L, List.of(v(Controle.VOL, Sanction.SETBACK)));
assertEquals(4, m.suivi(joueur).setbacksRecents(1003 * 50L, 60_000));
}
// --- M4 : VL de la cause remis à zéro ---
@Test
void M4_vlDuControleCauseRemisAZero() {
Moteur m = new Moteur(new GardeConfig());
long t = 50_000;
Suivi s = m.suivi(joueur);
s.vl.ajouter(Controle.STEP, 40, t);
s.vl.ajouter(Controle.NO_SLOW, 30, t);
s.vl.ajouter(Controle.KILLAURA_CIBLES, 7, t);
m.apresSetback(joueur, t, List.of(v(Controle.STEP, Sanction.SETBACK), v(Controle.NO_SLOW, Sanction.ALERTE)));
assertEquals(0, s.vl.valeur(Controle.STEP, t), 1e-9);
assertEquals(30, s.vl.valeur(Controle.NO_SLOW, t), 1e-9, "verdict sous SETBACK : VL gardé");
assertEquals(7, s.vl.valeur(Controle.KILLAURA_CIBLES, t), 1e-9, "contrôle sans rapport : VL gardé");
}
@Test
void M4_ancienneSignatureInchangee() {
Moteur m = new Moteur(new GardeConfig());
Suivi s = m.suivi(joueur);
s.vl.ajouter(Controle.STEP, 40, 0);
s.vl.ajouter(Controle.VOL, 40, 0);
m.apresSetback(joueur, 0);
assertEquals(40, s.vl.valeur(Controle.STEP, 0), 1e-9);
assertEquals(0, s.vl.valeur(Controle.VOL, 0), 1e-9);
}
// --- M2 : casses en chaîne d'un mod (exemption configurable, désactivée par défaut) ---
@Test
void M2_desactiveParDefaut() {
GardeConfig cfg = new GardeConfig();
assertFalse(cfg.nukerIgnorerCassesSansPaquet);
assertFalse(new Moteur(cfg).casseNukerSansPaquet(joueur, 42L, 5000));
}
@Test
void M2_activee_cassesDUnModIgnoreesNukerAvecPaquetsVu() {
GardeConfig cfg = new GardeConfig();
cfg.nukerIgnorerCassesSansPaquet = true;
Moteur m = new Moteur(cfg);
long t = 100 * 50L;
// Abattage d'arbre : un paquet sur la bûche du bas, 12 bûches cassées par le mod.
m.paquetCasse(joueur, 1L, t);
assertFalse(m.casseNukerSansPaquet(joueur, 1L, t), "le bloc visé par le joueur compte");
for (long k = 2; k <= 12; k++) assertTrue(m.casseNukerSansPaquet(joueur, k, t), "bûche du mod ignorée");
// Nuker de client : un paquet par bloc, tous comptés.
for (long k = 100; k < 110; k++) m.paquetCasse(joueur, k, t + 50);
for (long k = 100; k < 110; k++) assertFalse(m.casseNukerSansPaquet(joueur, k, t + 50));
// Un paquet d'un tick précédent ne couvre pas la casse de ce tick.
assertTrue(m.casseNukerSansPaquet(joueur, 1L, t + 100));
}
// --- M3 : blocs fantômes ---
private static final double[] CUBE = {0, 64, 0, 1, 65, 1};
private static final double[] OEIL = {0.5, 66.62, 2};
private static final double[] IMPACT = {0.5, 65, 0.5};
private double clicsAir(Moteur m, long cle, long debut, boolean changerAvant) {
double pts = 0;
for (int i = 0; i < 10; i++) {
long t = debut + i * 500L;
if (changerAvant) m.changementBloc(joueur, cle + i, t - 100);
for (Verdict x : m.interactionBloc(joueur, t, cle + i, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT,
true, true, 4.5, 0)) {
if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points();
}
}
return pts;
}
@Test
void M3_blocFantomeApresCasseNonCompte() {
assertEquals(0, clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, true), 1e-9);
}
@Test
void M3_airPlaceSurBlocJamaisChangeToujoursVu() {
assertTrue(clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, false) > 0);
}
@Test
void M3_changementAncienNeCouvrePas() {
Moteur m = new Moteur(new GardeConfig());
double pts = 0;
for (int i = 0; i < 10; i++) {
long t = 10_000 + i * 500L;
m.changementBloc(joueur, 7, t - 2000); // changé il y a 2 s : plus un bloc fantôme
for (Verdict x : m.interactionBloc(joueur, t, 7, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT, true, true, 4.5, 0)) {
if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points();
}
}
assertTrue(pts > 0);
}
@Test
void M3_memoireCirculaire() {
Suivi.PositionsRecentes r = new Suivi.PositionsRecentes();
for (int i = 0; i < 40; i++) r.noter(i, 1000);
assertFalse(r.contient(0, 1000, 0), "entrée la plus ancienne écrasée");
assertTrue(r.contient(39, 1000, 0));
assertFalse(r.contient(39, 999, 10), "instant futur refusé");
}
}
+128
Voir le fichier
@@ -0,0 +1,128 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/** 0.4.2 : vraies sanctions pour auto-totem et velocite, seuils propres a ces controles. */
class Sanctions042Test {
private GardeConfig cfg;
private Moteur moteur;
private final UUID j = UUID.randomUUID();
private long now;
@BeforeEach
void init() {
cfg = new GardeConfig();
moteur = new Moteur(cfg);
now = 1_000_000;
}
@Test
void seuilsParDefaut() {
assertEquals(9, cfg.autoTotemSeuilExpulsion, 1e-9);
assertEquals(8, cfg.velociteSeuilSetback, 1e-9);
assertEquals(16, cfg.velociteSeuilExpulsion, 1e-9);
}
@Test
void paliersVelocite() {
assertEquals(Sanction.ALERTE, Paliers.palier(7.9, cfg, Controle.VELOCITE));
assertEquals(Sanction.SETBACK, Paliers.palier(8, cfg, Controle.VELOCITE));
assertEquals(Sanction.SETBACK, Paliers.palier(15.9, cfg, Controle.VELOCITE));
assertEquals(Sanction.EXPULSION, Paliers.palier(16, cfg, Controle.VELOCITE));
}
@Test
void paliersAutoTotem() {
assertEquals(Sanction.EXPULSION, Paliers.palier(9, cfg, Controle.AUTO_TOTEM));
assertTrue(Paliers.palier(8.9, cfg, Controle.AUTO_TOTEM).ordinal() < Sanction.EXPULSION.ordinal());
}
@Test
void seuilsAZeroRetombentSurLesSeuilsGlobaux() {
cfg.velociteSeuilSetback = 0;
cfg.velociteSeuilExpulsion = 0;
cfg.autoTotemSeuilExpulsion = 0;
for (double vl : new double[] {3, 9, 12, 15, 25}) {
assertEquals(Paliers.palier(vl, cfg), Paliers.palier(vl, cfg, Controle.VELOCITE));
assertEquals(Paliers.palier(vl, cfg), Paliers.palier(vl, cfg, Controle.AUTO_TOTEM));
}
cfg.velociteSeuilSetback = 8;
assertEquals(Paliers.palier(9, cfg), Paliers.palier(9, cfg, Controle.VITESSE), "autres controles inchanges");
}
@Test
void sanctionMaxResteRespecte() {
cfg.sanctionMax = Sanction.SETBACK;
assertEquals(Sanction.SETBACK, Paliers.palier(50, cfg, Controle.VELOCITE));
}
private List<Verdict> totem() {
moteur.totemEclate(j, now, false);
now += 50;
return moteur.totemEnMain(j, now, EtatJoueur.normal(), true);
}
@Test
void autoTotemEnforceExpulseSansJamaisDeSetback() {
cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE);
Sanction pire = Sanction.AUCUNE;
int detections = 0;
for (int k = 0; k < 6 && pire != Sanction.EXPULSION; k++) {
for (Verdict v : totem()) {
detections++;
assertTrue(v.applicable() != Sanction.SETBACK, "palier SETBACK ramene a ALERTE");
if (v.applicable().ordinal() > pire.ordinal()) pire = v.applicable();
}
now += 300; // detections rapprochees
}
assertEquals(Sanction.EXPULSION, pire);
assertTrue(detections <= 4, "expulsion a la 3e ou 4e detection rapprochee : " + detections);
}
@Test
void autoTotemEnObserveJamaisDeSanction() {
for (int k = 0; k < 10; k++) {
for (Verdict v : totem()) assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal());
now += 300;
}
}
private Sanction recul() {
now += 2000;
moteur.reculApplique(j, now, 1, 0, 0.4, true);
Sanction pire = Sanction.AUCUNE;
for (int i = 0; i < 7; i++) {
now += 50;
for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) {
if (v.applicable().ordinal() > pire.ordinal()) pire = v.applicable();
}
}
return pire;
}
@Test
void velociteEnforceSetbackPuisExpulsion() {
cfg.mode(Controle.VELOCITE, Mode.ENFORCE);
cfg.setbacksAvantExpulsion = 0; // isole les seuils de velocite (C5 teste ailleurs)
boolean setback = false;
Sanction s = Sanction.AUCUNE;
for (int k = 0; k < 20 && s != Sanction.EXPULSION; k++) {
s = recul();
if (s == Sanction.SETBACK) setback = true;
}
assertTrue(setback, "retour en arriere avant l'expulsion");
assertEquals(Sanction.EXPULSION, s);
}
@Test
void velociteEnObserveJamaisDeSanction() {
for (int k = 0; k < 20; k++) assertTrue(recul().ordinal() <= Sanction.ALERTE.ordinal());
}
}
+117
Voir le fichier
@@ -0,0 +1,117 @@
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.UUID;
import org.junit.jupiter.api.Test;
/** 0.6, P3.2 : scaffold horizontal (pont hors regard, rotations snap). */
class ScaffoldP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/**
* n poses de pont, une toutes les 5 ticks. Rotation au moment de la pose (yawPose, pitchPose), rotation du paquet
* d'avant (yawAvant), rotation du paquet d'après (yawApres) ; direction du point cliqué (dirYaw, dirPitch).
*/
private int pont(Moteur m, EtatJoueur e, int n, float dirYaw, float dirPitch, float yawAvant, float yawPose,
float pitchPose, float yawApres, float pitchApres) {
int verdicts = 0;
for (int i = 0; i < n; i++) {
long t = 100 + i * 5L;
m.poseScaffold(joueur, e, dirYaw, dirPitch, yawAvant, pitchApres, yawPose, pitchPose);
for (Verdict v : m.regardScaffold(joueur, (t + 1) * 50L, t + 1, yawApres, pitchApres)) {
if (v.controle() == Controle.SCAFFOLD) verdicts++;
}
}
return verdicts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.SCAFFOLD));
assertEquals(Controle.SCAFFOLD, Controle.parse("scaffold"));
}
@Test
void geometrieDuPont() {
// joueur au bord d'un pont vers +x, bloc posé devant/sous ses pieds
assertTrue(Scaffold.estPont(11, 63, 20, 10.9, 64, 20.5, 0, 0.2));
// tower (dans la colonne), saut, immobile, trop loin : pas un pont
assertFalse(Scaffold.estPont(10, 63, 20, 10.5, 64, 20.5, 0, 0.2));
assertFalse(Scaffold.estPont(11, 63, 20, 10.9, 64, 20.5, 0.42, 0.2));
assertFalse(Scaffold.estPont(11, 63, 20, 10.9, 64, 20.5, 0, 0));
assertFalse(Scaffold.estPont(14, 63, 20, 10.9, 64, 20.5, 0, 0.2));
}
@Test
void rotationEtAngle() {
float[] r = Scaffold.rotation(0, -1, 0); // vers le bas
assertEquals(90, r[1], 1e-3);
r = Scaffold.rotation(0, 0, 1); // vers +z = yaw 0
assertEquals(0, r[0], 1e-3);
assertEquals(180, Scaffold.angle(0, 0, 180, 0), 1e-6);
assertEquals(0, Scaffold.angle(10, 90, 170, 90), 1e-3); // à la verticale, le yaw ne compte plus
}
@Test
void pontEnReculantHonneteNonVu() {
// Regard fixe vers l'arrière et le bas (yaw 180, pitch 78), point cliqué à 5° du regard.
assertEquals(0, pont(new Moteur(cfg), EtatJoueur.normal(), 60, 175, 80, 180, 180, 78, 180, 78));
}
@Test
void retournementRapideIsoleNonVu() {
// Un vrai joueur se retourne d'un coup pour poser derrière lui : une ou deux poses anormales, pas une série.
Moteur m = new Moteur(cfg);
int n = pont(m, EtatJoueur.normal(), 2, 180, 80, 0, 0, 0, 180, 80);
n += pont(m, EtatJoueur.normal(), 30, 175, 80, 180, 180, 78, 180, 78);
assertEquals(0, n);
}
@Test
void scaffoldSansRotationVu() {
// Regard devant (yaw 0, pitch 10), pose derrière sous les pieds (yaw 180, pitch 75) : hors regard en série.
int n = pont(new Moteur(cfg), EtatJoueur.normal(), 20, 180, 75, 0, 0, 10, 0, 10);
assertEquals(20 - cfg.scaffoldSerieMin + 1, n);
}
@Test
void scaffoldRotationSilencieuseSnapVu() {
// Rotation silencieuse : le paquet de la pose vise le bloc (yaw 180, pitch 80), celui d'avant et d'après
// regardent devant (yaw 0, pitch 5). Le point cliqué est dans le regard de la pose : seul le snap le trahit.
int n = pont(new Moteur(cfg), EtatJoueur.normal(), 20, 180, 80, 0, 180, 80, 0, 5);
assertEquals(20 - cfg.scaffoldSerieMin + 1, n);
}
@Test
void creatifElytresVolExemptes() {
for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().elytres(true).build(), EtatJoueur.builder().peutVoler(true).build(),
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().tps(12).build()}) {
assertEquals(0, pont(new Moteur(cfg), e, 30, 180, 75, 0, 0, 10, 0, 10), e.toString());
}
}
@Test
void enforceAnnuleLesPosesSuivantesSeulementQuandSuspect() {
cfg.mode(Controle.SCAFFOLD, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
assertFalse(m.scaffoldAnnuler(joueur, 0, 0));
pont(m, EtatJoueur.normal(), 40, 180, 75, 0, 0, 10, 0, 10);
long t = 100 + 40 * 5L;
assertTrue(m.scaffoldAnnuler(joueur, t * 50L, t));
// OBSERVE : jamais d'annulation
cfg.mode(Controle.SCAFFOLD, Mode.OBSERVE);
assertFalse(m.scaffoldAnnuler(joueur, t * 50L, t));
}
@Test
void sansPoseRienAJuger() {
Moteur m = new Moteur(cfg);
assertEquals(0, m.regardScaffold(joueur, 0, 0, 0, 0).size());
}
}
+45
Voir le fichier
@@ -0,0 +1,45 @@
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, P2.12 : Spider / WallClimb. Pas de nouveau contrôle : la montée le long d'un mur hors échelle, lianes ou
* échafaudage (milieu spécial) viole la gravité, que le contrôle vol (en ENFORCE en production) mesure déjà. Ces tests
* le vérifient pour les vitesses de montée des modules courants (0,2 et 0,12 bloc/tick) et la variante qui alterne.
*/
class SpiderP2Test {
private final GardeConfig cfg = new GardeConfig();
private double vol(java.util.function.IntFunction<EtatMouvement> f, int n) {
Moteur m = new Moteur(cfg);
UUID j = UUID.randomUUID();
double pts = 0;
for (int i = 0; i < n; i++) {
for (Verdict v : m.mouvement(j, i * 50L, EtatJoueur.normal(), f.apply(i))) {
if (v.controle() == Controle.VOL) pts += v.points();
}
}
return pts;
}
private static EtatMouvement montee(double dy, boolean milieu) {
return new EtatMouvement(0.0, dy, 1, false, false, false, false, false, 0, 0, milieu, false);
}
@Test
void monteeContreUnMurVueParVol() {
assertTrue(vol(i -> montee(0.2, false), 30) > 0);
assertTrue(vol(i -> montee(0.12, false), 30) > 0);
assertTrue(vol(i -> montee(i % 2 == 0 ? 0.3 : 0.0, false), 40) > 0, "montée par à-coups");
}
@Test
void echelleNonComptee() {
assertEquals(0, vol(i -> montee(0.1176, true), 60), 1e-9); // vitesse vanilla à l'échelle, milieu spécial
}
}
+108
Voir le fichier
@@ -0,0 +1,108 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P1.9 : step (marche trop haute en un tick, au sol avant et après). */
class StepP1Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** Joueur vanilla : max(step_height 0,6, saut 0,42). */
private static final double VANILLA = 0.6;
private static EtatMouvement sol(double dy, boolean solServeur) {
return new EtatMouvement(0.2, dy, 1, solServeur, solServeur, false, false, false, 0, 0, false, false);
}
private double step(Moteur m, double hauteur, EtatMouvement... suite) {
double total = 0;
long t = 0;
for (EtatMouvement e : suite) {
t += 50;
for (Verdict v : m.mouvement(joueur, t, EtatJoueur.normal(), e, hauteur)) {
if (v.controle() == Controle.STEP) total += v.points();
}
}
return total;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.STEP));
assertEquals(2, Controle.STEP.fiabilite(), "plafond faible du score");
assertEquals(Controle.STEP, Controle.parse("step"));
}
@Test
void unBlocEnUnTickAuSolEstVu() {
assertTrue(step(new Moteur(cfg), VANILLA, sol(0, true), sol(1.0, true)) > 0);
}
@Test
void dallesEscaliersEtLitsNeComptentPas() {
Moteur m = new Moteur(cfg);
assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.5, true), sol(0.5, true), sol(0.5625, true), sol(0.6, true)), 1e-9);
assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.69, true)), 1e-9, "dans la marge");
}
@Test
void attributStepOuSautAmelioreReleveLeSeuil() {
assertEquals(0, step(new Moteur(cfg), 1.0, sol(0, true), sol(1.0, true)), 1e-9, "attribut step_height 1,0");
// Saut amélioré V : 0,42 + 0,5 = 0,92 en un tick ; atterrir sur un bloc de 0,9 n'est pas un step.
assertEquals(0, step(new Moteur(cfg), 0.92, sol(0, true), sol(0.9, true)), 1e-9);
}
@Test
void sautOrdinaireEtAirPasMesures() {
// Saut : en l'air après le premier tick (sol serveur faux), puis retombée sur un bloc.
Moteur m = new Moteur(cfg);
assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.42, false), sol(0.33, false), sol(0.25, true)), 1e-9);
// Pas de sol au paquet précédent : rien
assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, false), sol(1.0, true)), 1e-9);
}
@Test
void plusieursTicksMilieuSpecialOuHauteurInconnuePasMesures() {
EtatMouvement deuxTicks = new EtatMouvement(0.4, 1.0, 2, true, true, false, false, false, 0, 0, false, false);
assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, true), deuxTicks), 1e-9);
EtatMouvement echelle = new EtatMouvement(0, 1.0, 1, true, true, false, false, false, 0, 0, true, false);
assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, true), echelle), 1e-9);
assertEquals(0, step(new Moteur(cfg), Double.NaN, sol(0, true), sol(1.0, true)), 1e-9, "piston proche");
// L'ancienne signature (traces, rejeu) ne mesure jamais step.
Moteur m = new Moteur(cfg);
m.mouvement(joueur, 50, EtatJoueur.normal(), sol(0, true));
List<Verdict> v = m.mouvement(joueur, 100, EtatJoueur.normal(), sol(1.0, true));
assertTrue(v.stream().noneMatch(x -> x.controle() == Controle.STEP));
}
@Test
void exemptionCoupeEtRemetLaReferenceAZero() {
Moteur m = new Moteur(cfg);
m.mouvement(joueur, 50, EtatJoueur.normal(), sol(0, true), VANILLA);
EtatJoueur teleport = EtatJoueur.builder().ticksDepuisTeleport(1).build();
assertTrue(m.mouvement(joueur, 100, teleport, sol(1.0, true), VANILLA).isEmpty());
// Juste après l'exemption : pas de référence, le gain n'est pas compté.
List<Verdict> v = m.mouvement(joueur, 150, EtatJoueur.normal(), sol(1.0, true), VANILLA);
assertTrue(v.stream().noneMatch(x -> x.controle() == Controle.STEP));
}
@Test
void enObserveJamaisDeSanction() {
Moteur m = new Moteur(cfg);
Sanction pire = Sanction.AUCUNE;
long t = 0;
for (int i = 0; i < 40; i++) {
t += 50;
m.mouvement(joueur, t, EtatJoueur.normal(), sol(0, true), VANILLA);
t += 50;
Sanction s = Verdict.pire(m.mouvement(joueur, t, EtatJoueur.normal(), sol(1.2, true), VANILLA));
if (s.ordinal() > pire.ordinal()) pire = s;
}
assertTrue(pire.ordinal() <= Sanction.ALERTE.ordinal(), "OBSERVE : au plus une alerte, " + pire);
}
}
+294
Voir le fichier
@@ -0,0 +1,294 @@
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.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
/** Score de suspicion 0-100 (0.4.0) : contributions, plafonds, décroissance, diversité, paliers, historique. */
class SuspicionTest {
private static final long MIN = 60_000L;
private GardeConfig cfg;
private Suspicion s;
@BeforeEach
void init() {
cfg = new GardeConfig();
s = new Suspicion(cfg);
}
@Test
void valeursParDefautDeLaConception() {
assertEquals(25, cfg.suspicionSeuilSurveiller);
assertEquals(50, cfg.suspicionSeuilSuspect);
assertEquals(75, cfg.suspicionSeuilFort);
assertEquals(10, cfg.suspicionDemiVieMinutes);
assertEquals(50, cfg.suspicionPlafondFiable);
assertEquals(30, cfg.suspicionPlafondMoyen);
assertEquals(15, cfg.suspicionPlafondFaible);
assertEquals(3, cfg.suspicionDiversiteControles);
assertEquals(10, cfg.suspicionDiversiteFenetreMinutes);
assertEquals(7, cfg.suspicionHistoriqueJours);
assertTrue(cfg.suspicionActive);
}
@Test
void fiabiliteDeChaqueControle() {
List<Controle> fiables = List.of(Controle.VOL, Controle.VITESSE, Controle.NO_FALL, Controle.PORTEE,
Controle.HITBOX, Controle.REGULARITE, Controle.AUTO_TOTEM);
List<Controle> moyens = List.of(Controle.COUPS_HORS_BOITE, Controle.KILLAURA_ANGLE, Controle.KILLAURA_CIBLES,
Controle.CADENCE);
for (Controle c : Controle.values()) {
double attendu = fiables.contains(c) ? 50 : moyens.contains(c) ? 30 : 15;
assertEquals(attendu, Suspicion.plafond(c, cfg), c.id());
}
}
@Test
void contributionNormaliseeParLeSeuilDExpulsionEtPlafonnee() {
s.noter(Controle.VOL, 10, false, 0); // moitié du seuil d'expulsion (20)
assertEquals(25, s.score(0), 1e-9);
s.noter(Controle.VOL, 20, false, 0);
assertEquals(50, s.score(0), 1e-9);
s.noter(Controle.VOL, 5000, false, 0); // au-delà : plafonné
assertEquals(50, s.score(0), 1e-9);
}
@Test
void plafondsParFiabilite() {
s.noter(Controle.CADENCE, 999, false, 0);
assertEquals(30, s.score(0), 1e-9);
Suspicion t = new Suspicion(cfg);
t.noter(Controle.TIMER, 1331, false, 0); // le timer a atteint 1331 en jeu
assertEquals(15, t.score(0), 1e-9);
assertEquals(Suspicion.Niveau.NORMAL, t.niveau(0), "un contrôle à faux positifs ne rend jamais suspect seul");
for (Controle c : List.of(Controle.ROTATION, Controle.ATTAQUE_IMPOSSIBLE, Controle.VEHICULE_VITESSE,
Controle.VEHICULE_VOL, Controle.TIMER)) {
t.noter(c, 999, false, 0);
}
// 5 contrôles faibles saturés = 75 : possible, mais seulement par accumulation (et par diversité, voir plus bas)
assertEquals(75, t.score(0), 1e-9);
}
@Test
void sommePlafonneeACent() {
for (Controle c : List.of(Controle.VOL, Controle.VITESSE, Controle.NO_FALL, Controle.PORTEE)) {
s.noter(c, 20, false, 0);
}
assertEquals(100, s.score(0), 1e-9);
}
@Test
void demiVieDeDixMinutes() {
s.noter(Controle.VITESSE, 20, false, 0);
assertEquals(50, s.score(0), 1e-9);
assertEquals(25, s.score(10 * MIN), 1e-6);
assertEquals(12.5, s.score(20 * MIN), 1e-6);
assertEquals(Suspicion.Niveau.A_SURVEILLER, s.niveau(10 * MIN));
assertEquals(Suspicion.Niveau.NORMAL, s.niveau(11 * MIN));
}
@Test
void ledecompteNeCompteQueLePicEtNonLeVlQuiRetombe() {
// Le VL retombe à 0 (setback ou 0,5/s) mais le pic reste dans le score jusqu'à décroissance.
s.noter(Controle.VOL, 20, true, 0);
s.noter(Controle.VOL, 1, false, 30_000); // VL reparti de zéro : le pic de 20 ne baisse pas
double apres = s.score(30_000);
assertTrue(apres > 45 && apres <= 50, "pic gardé, un peu décru : " + apres);
}
@Test
void diversiteTroisControlesAuPalierSetbackDonneSuspectFort() {
// Trois contrôles faibles, chacun à moitié : 3 x 7,5 = 22,5 (normal) sans la règle de diversité.
s.noter(Controle.TIMER, 10, true, 0);
s.noter(Controle.ROTATION, 10, true, 1 * MIN);
assertTrue(s.score(1 * MIN) < 25);
assertEquals(Suspicion.Niveau.NORMAL, s.niveau(1 * MIN));
s.noter(Controle.VEHICULE_VITESSE, 10, true, 2 * MIN);
assertTrue(s.score(2 * MIN) >= 75, "diversité : au moins suspect fort, score " + s.score(2 * MIN));
assertEquals(Suspicion.Niveau.SUSPECT_FORT, s.niveau(2 * MIN));
assertEquals(3, s.controlesDivers(2 * MIN));
}
@Test
void diversiteDeuxControlesNeSuffitPasEtLaFenetreExpire() {
s.noter(Controle.TIMER, 10, true, 0);
s.noter(Controle.ROTATION, 10, true, 1 * MIN);
assertFalse(s.score(1 * MIN) >= 75);
// Le troisième arrive après 10 minutes : le premier est sorti de la fenêtre.
s.noter(Controle.VEHICULE_VITESSE, 10, true, 10 * MIN + 1);
assertEquals(2, s.controlesDivers(10 * MIN + 1));
assertTrue(s.score(10 * MIN + 1) < 75);
}
@Test
void diversiteExigeLePalierSetback() {
s.noter(Controle.TIMER, 10, true, 0);
s.noter(Controle.ROTATION, 10, true, 0);
s.noter(Controle.VEHICULE_VITESSE, 4, false, 0); // seulement journal / alerte
assertEquals(2, s.controlesDivers(0));
assertTrue(s.score(0) < 75);
}
@Test
void diversiteCoupeeParLaConfiguration() {
cfg.suspicionDiversiteControles = 0;
s.noter(Controle.TIMER, 10, true, 0);
s.noter(Controle.ROTATION, 10, true, 0);
s.noter(Controle.VEHICULE_VITESSE, 10, true, 0);
assertTrue(s.score(0) < 75);
}
@Test
void transitionsUneSeuleFoisParPalierEtReArmement() {
s.noter(Controle.VOL, 10, false, 0); // 25
assertEquals(Suspicion.Niveau.A_SURVEILLER, s.prendreTransition());
assertNull(s.prendreTransition(), "consommée");
s.noter(Controle.VOL, 10.5, false, 1); // encore 26 : même palier
assertNull(s.prendreTransition());
s.noter(Controle.VITESSE, 10, false, 2); // 50
assertEquals(Suspicion.Niveau.SUSPECT, s.prendreTransition());
s.noter(Controle.NO_FALL, 10, false, 3); // 75
assertEquals(Suspicion.Niveau.SUSPECT_FORT, s.prendreTransition());
s.noter(Controle.NO_FALL, 20, false, 4);
assertNull(s.prendreTransition(), "déjà notifié");
// Longtemps après, le score est retombé sous 25 : le palier peut de nouveau être franchi.
s.noter(Controle.TIMER, 1, false, 60 * MIN);
s.prendreTransition();
s.noter(Controle.VOL, 20, false, 60 * MIN + 1);
assertEquals(Suspicion.Niveau.SUSPECT, s.prendreTransition());
}
@Test
void passageDirectAuFortParDiversiteNEmetQueLeFort() {
s.noter(Controle.TIMER, 10, true, 0);
s.noter(Controle.ROTATION, 10, true, 0);
s.noter(Controle.VEHICULE_VITESSE, 10, true, 0);
assertEquals(Suspicion.Niveau.SUSPECT_FORT, s.prendreTransition());
assertNull(s.prendreTransition());
}
@Test
void desactiveParLaConfiguration() {
cfg.suspicionActive = false;
s.noter(Controle.VOL, 20, true, 0);
assertEquals(0, s.score(0));
assertNull(s.prendreTransition());
}
@Test
void horlogeQuiRecule_PasDeScoreNegatifNiDeRemontee() {
s.noter(Controle.VOL, 20, false, 10 * MIN);
double avant = s.score(10 * MIN);
s.noter(Controle.VITESSE, 0, false, 5 * MIN); // horloge en arrière : ignorée
assertEquals(avant, s.score(10 * MIN), 1e-9);
}
// --- Dans le moteur : contrôles en OBSERVE inclus, aucune sanction, historique ---
private static void tapesRegulieres(Moteur m, UUID id, int n, long[] t, java.util.List<Verdict> sortie) {
for (int i = 0; i < n; i++) {
t[0] += 50;
sortie.addAll(m.attaque(id, t[0], EtatJoueur.normal(), -1, 1, true));
}
}
@Test
void controlesEnObserveComptentMaisNeSanctionnentPas() {
GardeConfig c = new GardeConfig();
c.mode(Controle.REGULARITE, Mode.OBSERVE);
Moteur m = new Moteur(c);
long[] horloge = {0};
m.horloge(() -> horloge[0]);
UUID id = UUID.randomUUID();
java.util.List<Verdict> vs = new java.util.ArrayList<>();
tapesRegulieres(m, id, 60, horloge, vs);
assertTrue(vs.stream().allMatch(v -> v.applicable().ordinal() <= Sanction.ALERTE.ordinal()),
"OBSERVE ne dépasse jamais l'alerte");
assertEquals(50, m.scoreSuspicion(id), 1e-6, "la régularité en OBSERVE a atteint son plafond de 50");
Moteur.AlerteSuspicion a = m.alerteSuspicion(id, 1_000_000L);
assertNotNull(a);
assertEquals(Suspicion.Niveau.SUSPECT, a.niveau());
}
@Test
void alerteEnregistreLIncidentDansLHistoriqueSeulementDesSuspect() {
GardeConfig c = new GardeConfig();
Moteur m = new Moteur(c);
long[] horloge = {0};
m.horloge(() -> horloge[0]);
UUID id = UUID.randomUUID();
// Cadence (moyen, 30 max) : reste « à surveiller » ; pas d'incident dans l'historique.
m.suivi(id).suspicion.noter(Controle.CADENCE, 20, false, 0);
Moteur.AlerteSuspicion a = m.alerteSuspicion(id, 5_000L);
assertEquals(Suspicion.Niveau.A_SURVEILLER, a.niveau());
assertEquals(0, a.incidents());
m.suivi(id).suspicion.noter(Controle.REGULARITE, 8, false, 0);
a = m.alerteSuspicion(id, 6_000L);
assertEquals(Suspicion.Niveau.SUSPECT, a.niveau());
assertEquals(1, a.incidents());
assertTrue(a.controles().contains("regularite:20"), a.controles());
assertNull(m.alerteSuspicion(id, 7_000L));
}
@Test
void scoreRepartDeZeroApresReconnexion() {
Moteur m = new Moteur(new GardeConfig());
m.horloge(() -> 0L);
UUID id = UUID.randomUUID();
m.suivi(id).suspicion.noter(Controle.VOL, 20, false, 0);
assertTrue(m.scoreSuspicion(id) > 0);
m.retirer(id);
assertEquals(0, m.scoreSuspicion(id));
}
// --- Historique persistant ---
@Test
void historiquePersisteEtOublieLesVieuxIncidents(@TempDir Path dir) throws IOException {
Path f = dir.resolve("sous-dossier").resolve("incidents.csv");
long jour = 86_400_000L;
long maintenant = 100 * jour;
UUID a = UUID.randomUUID();
UUID b = UUID.randomUUID();
HistoriqueSuspicion h = new HistoriqueSuspicion();
h.ouvrir(f, maintenant, 7);
h.enregistrer(a, maintenant - 8 * jour, Suspicion.Niveau.SUSPECT, 55, "vol:50");
h.enregistrer(a, maintenant - 3 * jour, Suspicion.Niveau.SUSPECT_FORT, 80, "vol:50;vitesse:30"); // ';' neutralisé
h.enregistrer(b, maintenant - 1 * jour, Suspicion.Niveau.SUSPECT, 50, "regularite:50");
assertEquals(1, h.incidents(a, maintenant, 7), "celui de 8 jours est hors fenêtre même en mémoire");
// Redémarrage : relecture du fichier, le vieil incident est écarté et le fichier réécrit compact.
Files.writeString(f, "ligne illisible\n", StandardCharsets.UTF_8, java.nio.file.StandardOpenOption.APPEND);
HistoriqueSuspicion h2 = new HistoriqueSuspicion();
h2.ouvrir(f, maintenant, 7);
assertEquals(1, h2.incidents(a, maintenant, 7));
assertEquals(1, h2.incidents(b, maintenant, 7));
assertEquals(0, h2.incidents(UUID.randomUUID(), maintenant, 7));
assertEquals(2, Files.readAllLines(f).size(), "fichier compact : plus de vieille ligne ni de ligne illisible");
// Plus tard, l'incident de a sort aussi de la fenêtre.
assertEquals(0, h2.incidents(a, maintenant + 5 * jour, 7));
}
@Test
void historiqueSansFichierResteEnMemoire() {
HistoriqueSuspicion h = new HistoriqueSuspicion();
UUID a = UUID.randomUUID();
h.enregistrer(a, 1000, Suspicion.Niveau.SUSPECT, 50, "x");
assertEquals(1, h.incidents(a, 2000, 7));
}
}
+84
Voir le fichier
@@ -0,0 +1,84 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P1.12 : timer, solde actif par défaut (20), dette réglable, connexion ignorée. */
class TimerP1Test {
private final UUID joueur = UUID.randomUUID();
private static double points(List<Verdict> vs) {
return vs.stream().filter(v -> v.controle() == Controle.TIMER).mapToDouble(Verdict::points).sum();
}
private static double regulier(GardeConfig cfg, UUID j, long intervalleMs, int secondes, EtatJoueur e) {
Moteur m = new Moteur(cfg);
double total = 0;
for (long t = 0; t < secondes * 1000L; t += intervalleMs) total += points(m.paquetMouvement(j, 10_000 + t, e));
return total;
}
/** 1 s sans paquet puis 20 paquets d'un coup, puis 2 s normales, répété. */
private static double lags(GardeConfig cfg, UUID j) {
Moteur m = new Moteur(cfg);
double total = 0;
long t = 10_000;
for (int r = 0; r < 20; r++) {
t += 1000;
for (int i = 0; i < 20; i++) total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
for (int i = 0; i < 40; i++) {
t += 50;
total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
}
}
return total;
}
@Test
void soldeActifParDefaut() {
GardeConfig cfg = new GardeConfig();
assertEquals(20, cfg.timerSoldeMax);
assertEquals(40, cfg.timerDetteMax);
assertTrue(regulier(cfg, joueur, 46, 30, EtatJoueur.normal()) > 0, "timer 1,09 vu sans réglage");
assertEquals(0, regulier(cfg, joueur, 50, 60, EtatJoueur.normal()), 1e-9, "20 paquets/s : rien");
assertEquals(0, lags(cfg, joueur), 1e-9, "rattrapage après lag : rien");
}
/** 2 s sans paquet puis les 40 paquets en retard d'un coup (rattrapage exact), puis 2 s normales, répété. */
private static double rattrapages(GardeConfig cfg, UUID j) {
Moteur m = new Moteur(cfg);
double total = 0;
long t = 10_000;
for (int i = 0; i < 40; i++, t += 50) total += points(m.paquetMouvement(j, t, EtatJoueur.normal())); // amorce
for (int r = 0; r < 10; r++) {
t += 2000;
for (int i = 0; i < 40; i++) total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
for (int i = 0; i < 40; i++) {
t += 50;
total += points(m.paquetMouvement(j, t, EtatJoueur.normal()));
}
}
return total;
}
@Test
void detteReglableLeRattrapageExactNeCompteQuAvecUnCredit() {
GardeConfig cfg = new GardeConfig();
assertEquals(0, rattrapages(cfg, joueur), 1e-9, "dette 40 : rattrapage exact de 2 s, rien");
cfg.timerDetteMax = 0; // aucun crédit : la rafale qui suit le trou fait monter le solde
assertTrue(rattrapages(cfg, joueur) > 0, "la dette est bien le réglage utilisé");
}
@Test
void connexionRecenteIgnoree() {
GardeConfig cfg = new GardeConfig();
EtatJoueur connexion = EtatJoueur.builder().connexionRecente(true).build();
assertEquals(0, regulier(cfg, joueur, 20, 10, connexion), 1e-9, "50 paquets/s pendant le chargement : rien");
assertTrue(regulier(cfg, joueur, 20, 10, EtatJoueur.normal()) > 0, "témoin hors grâce");
}
}
+67
Voir le fichier
@@ -0,0 +1,67 @@
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, P2.7 : auto-totem-regulier (distribution des délais de remise). */
class TotemRegulierP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** Une série d'éclatements, chaque totem remis après le délai donné (ms, multiple de 50). */
private double points(Moteur m, Controle c, long... delais) {
double pts = 0;
long t = 1_000_000;
m.suivi(joueur);
for (long d : delais) {
m.totemEclate(joueur, t, false);
for (long x = 50; x <= d; x += 50) {
for (Verdict v : m.totemEnMain(joueur, t + x, EtatJoueur.normal(), x >= d)) {
if (v.controle() == c) pts += v.points();
}
}
t += 60_000;
}
return pts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.AUTO_TOTEM_REGULIER));
assertEquals(Controle.AUTO_TOTEM_REGULIER, Controle.parse("auto-totem-regulier"));
}
@Test
void delaiFixeAuDessusDuSeuilVu() {
// 250 ms à chaque fois : passe auto-totem (150 + ping 30) mais pas la distribution.
Moteur m = new Moteur(cfg);
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM, 250, 250, 250, 250, 250), 1e-9);
assertTrue(points(m, Controle.AUTO_TOTEM_REGULIER, 250, 250, 250, 250, 250) > 0);
}
@Test
void humainVarieJamaisVu() {
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 250, 400, 300, 650, 350, 900, 450), 1e-9);
// rapide mais variable : écart type > 30 ms
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 200, 250, 150, 250, 200), 1e-9);
// régulier mais lent (≥ 300 ms) : pas compté
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 350, 350, 350, 350, 350), 1e-9);
}
@Test
void moinsDeCinqEchantillonsRien() {
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM_REGULIER, 250, 250, 250, 250), 1e-9);
}
@Test
void marcheMemeSiAutoTotemEstCoupe() {
cfg.mode(Controle.AUTO_TOTEM, Mode.OFF);
Moteur m = new Moteur(cfg);
assertTrue(points(m, Controle.AUTO_TOTEM_REGULIER, 250, 250, 250, 250, 250) > 0);
assertEquals(0, points(new Moteur(cfg), Controle.AUTO_TOTEM, 50, 50, 50), 1e-9, "auto-totem coupé : aucun verdict");
}
}
+80
Voir le fichier
@@ -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);
}
}
+72
Voir le fichier
@@ -0,0 +1,72 @@
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, P2.10 : x-ray statistique (alerte seulement). */
class XrayP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** n blocs cassés à y = -50 ; tous les k blocs un rare, exposé ou non. */
private double miner(Moteur m, EtatJoueur e, int n, int k, boolean expose) {
double pts = 0;
for (int i = 1; i <= n; i++) {
boolean rare = i % k == 0;
for (Verdict v : m.casseXray(joueur, i * 1000L, e, -50, rare, expose)) {
pts += v.points();
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal());
}
}
return pts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.XRAY));
}
@Test
void mineraisCachesEnSerieAlerte() {
// 1 rare caché tous les 10 blocs (10 %) : alerte au 12e.
assertTrue(miner(new Moteur(cfg), EtatJoueur.normal(), 200, 10, false) > 0);
}
@Test
void minageHonneteJamaisAlerte() {
// Minerais trouvés dans les parois (exposés), même à 10 %.
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.normal(), 2000, 10, true), 1e-9);
// Minerais cachés mais rares (1 %, minage en branche).
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.normal(), 2000, 100, false), 1e-9);
}
@Test
void unFilonChanceuxNeSuffitPas() {
Moteur m = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < 8; i++) pts += m.casseXray(joueur, i, EtatJoueur.normal(), -50, true, false).stream().mapToDouble(Verdict::points).sum();
assertEquals(0, pts, 1e-9);
}
@Test
void enSurfaceEtCreatifRien() {
Moteur m = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < 100; i++) pts += m.casseXray(joueur, i, EtatJoueur.normal(), 60, true, false).size();
assertEquals(0, pts, 1e-9);
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.builder().creatif(true).build(), 200, 10, false), 1e-9);
}
@Test
void jamaisDeSanctionMemeEnEnforce() {
cfg.mode(Controle.XRAY, Mode.ENFORCE);
cfg.seuilAlerte = 0.5;
cfg.seuilSetback = 1;
cfg.seuilExpulsion = 1.5;
assertTrue(miner(new Moteur(cfg), EtatJoueur.normal(), 400, 10, false) > 0); // l'assertion ≤ ALERTE est dans miner
}
}