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>
Cette révision appartient à :
1 Parent
adc326a897
révision
c49cf985d8
9 fichiers modifiés
+247
-3
Aucun fichier ne correspond à votre recherche
@@ -720,6 +720,10 @@ public final class Garde {
|
||||
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em, hauteurPermise(p));
|
||||
Sanction s = traiter(p, 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())) {
|
||||
@@ -908,10 +912,16 @@ 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.STEP) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.ANTI_FAIM) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.ANTI_FAIM) != Mode.OFF || CONFIG.mode(Controle.NO_SLOW) != 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);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
|
||||
@@ -27,6 +27,9 @@ public final class GardeSpec {
|
||||
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;
|
||||
|
||||
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
|
||||
private static final ModConfigSpec.IntValue CIBLES_MAX;
|
||||
@@ -265,6 +268,13 @@ public final class GardeSpec {
|
||||
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);
|
||||
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 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic");
|
||||
@@ -436,6 +446,9 @@ public final class GardeSpec {
|
||||
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.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
|
||||
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
|
||||
c.graceReculTicks = GRACE_RECUL.get();
|
||||
|
||||
@@ -29,7 +29,9 @@ public enum Controle {
|
||||
/** 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");
|
||||
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");
|
||||
|
||||
private final String id;
|
||||
|
||||
@@ -57,7 +59,8 @@ public enum Controle {
|
||||
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 -> 2;
|
||||
case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM,
|
||||
NO_SLOW -> 2; // 0.5 (P2) : idem
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
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;
|
||||
|
||||
public FaitsMouvement ticksUsage(int v) {
|
||||
ticksUsage = v;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -181,6 +181,14 @@ public final class GardeConfig {
|
||||
/** 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;
|
||||
|
||||
// --- 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;
|
||||
|
||||
@@ -448,6 +448,33 @@ public final class Moteur {
|
||||
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;
|
||||
if (!noSlow) 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();
|
||||
return List.of();
|
||||
}
|
||||
List<Verdict> verdicts = new ArrayList<>(1);
|
||||
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;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -65,6 +65,8 @@ public final class Suivi {
|
||||
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 (P1.6) : déploiements d'élytres répétés. */
|
||||
public final DeploiementsElytres deploiements = new DeploiementsElytres();
|
||||
/** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */
|
||||
|
||||
@@ -0,0 +1,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);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur