F11 (suite) : regard de reference par tick serveur, une inondation de paquets ne le chasse plus
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
ec17ccae5d
révision
6329cd3d63
3 fichiers modifiés
+46
-13
Aucun fichier ne correspond à votre recherche
@@ -18,7 +18,7 @@ Base avant corrections : 98 tests verts.
|
||||
| F12 cadence saturée | corrigée | `git log --grep F12` | `AuditFaillesTest.F12_*` (2), `ControlesTest.cadenceFolleSoutenue` (1,8 au lieu de 2,0 : bord de tranche) ; 118 verts | essai en jeu n° 10 (combat honnête contre plusieurs zombies, aucune ligne `cadence`) |
|
||||
| F13 cibles saturées | corrigée | `git log --grep F13` | `AuditFaillesTest.F13_*` (rouge avant) ; 119 verts | essai en jeu n° 10 |
|
||||
| F20 véhicules | corrigée (bornes [À VÉRIFIER]) | `git log --grep F20` | `AuditFaillesTest.F20_*` (5) ; `MixinsAppliquesTest` couvre la nouvelle injection ; 126 verts | essai en jeu n° 14 + bateau sur glace bleue, cheval rapide, chameau (dash), cochon, arpenteur : aucune fausse alerte ; rejeu des lignes `veh` non écrit |
|
||||
| F11 rotation silencieuse | corrigée (seuils [À VÉRIFIER]) | `git log --grep F11` | `AuditFaillesTest.F11_*` (2) ; 124 verts | essai en jeu n° 11 ; PvP honnête rapide sans ligne `rotation` |
|
||||
| F11 rotation silencieuse | corrigée (seuils [À VÉRIFIER]) | `git log --grep F11` | `AuditFaillesTest.F11_*` (3) ; 127 verts | essai en jeu n° 11 ; PvP honnête rapide sans ligne `rotation` |
|
||||
| F19, F22, F25 | essais en jeu seulement | | | `audit/ESSAIS-EN-JEU.md` |
|
||||
| Version 0.3.0, jar, README, script | à faire | | | |
|
||||
|
||||
@@ -80,3 +80,4 @@ Base avant corrections : 98 tests verts.
|
||||
- Le coup a déjà eu lieu quand l'aller-retour est vu : journal et VL seulement, aucune sanction directe.
|
||||
- Non fait (audit) : vitesse de rotation avant le coup, deux cibles espacées de plus de 90° en moins de 3 ticks ; une killaura qui revient lentement (plus de 3 ticks) ou ne revient pas passe encore. Reach jamais mesuré (contrôle à ajouter, synthèse n° 3).
|
||||
- Suite (revue de sécurité du commit F20) : (1) la distance permise se compte en ticks serveur écoulés : un solde (crédit plafonné à 2 ticks, dette au-delà de 1,5 bloc = infraction) remplace le tampon par paquet ; dix paquets dans un tick ne valent plus dix fois la distance (`F20_paquets_multiples_dans_un_tick_vus`, gigue honnête incluse). (2) Sur la glace, borne du type (bateau 4,0 ; monture ×2) au lieu de l'infini, élan plafonné à 4,0 (`F20_elan_de_glace_borne`). (3) En véhicule, la position de retour n'est mémorisée qu'après un paquet de véhicule sans verdict. (4) Changer de véhicule ou remonter ne remet le temps en l'air et le solde à zéro qu'après 2 s sans véhicule.
|
||||
- F11 suite (revue de sécurité du commit F11) : le regard de référence est le regard de fin de tick des 4 derniers ticks serveur, et non plus des 8 derniers paquets : une inondation de paquets de rotation ne le chasse plus (`F11_inondation_de_rotations_vue`).
|
||||
@@ -11,21 +11,28 @@ package com.gastinelgarde.core;
|
||||
* honnête qui se tourne vers sa cible continue de la regarder, ou repart ailleurs, mais revient rarement pile
|
||||
* en arrière en un ou deux ticks. Seuils à régler avec les traces [À VÉRIFIER] (combat PvP rapide).
|
||||
*
|
||||
* <p>Coût constant : 8 derniers regards.
|
||||
* <p>Coût constant : le dernier regard reçu et le regard de fin des 4 derniers ticks serveur. L'historique avance
|
||||
* par tick serveur, pas par paquet (revue de sécurité de F11 : huit paquets de rotation en deux ticks chassaient
|
||||
* le regard de référence d'un historique par paquet).
|
||||
*/
|
||||
public final class RotationSilencieuse {
|
||||
|
||||
public static final double SNAP_DEGRES = 45.0;
|
||||
public static final double RETOUR_DEGRES = 15.0;
|
||||
public static final int DELAI_TICKS = 3;
|
||||
private static final int HISTORIQUE = 8;
|
||||
private static final int HISTORIQUE = 4;
|
||||
|
||||
/** Regard de fin de tick des derniers ticks serveur où un regard a été reçu. */
|
||||
private final long[] ticks = new long[HISTORIQUE];
|
||||
private final float[] yaws = new float[HISTORIQUE];
|
||||
private final float[] pitchs = new float[HISTORIQUE];
|
||||
private int taille;
|
||||
private int tete; // prochaine case écrite
|
||||
|
||||
private boolean aRegard;
|
||||
private long tickCourant;
|
||||
private float yawCourant, pitchCourant;
|
||||
|
||||
private boolean enAttente;
|
||||
private float avantYaw, avantPitch, coupYaw, coupPitch;
|
||||
private long limite;
|
||||
@@ -36,11 +43,18 @@ public final class RotationSilencieuse {
|
||||
* @return points (1 si un aller-retour autour d'un coup vient de se terminer, 0 sinon)
|
||||
*/
|
||||
public double regard(long tick, float yaw, float pitch) {
|
||||
ticks[tete] = tick;
|
||||
yaws[tete] = yaw;
|
||||
pitchs[tete] = pitch;
|
||||
tete = (tete + 1) % HISTORIQUE;
|
||||
if (taille < HISTORIQUE) taille++;
|
||||
if (aRegard && tick > tickCourant) {
|
||||
// Nouveau tick : le dernier regard du tick précédent devient son regard de fin.
|
||||
ticks[tete] = tickCourant;
|
||||
yaws[tete] = yawCourant;
|
||||
pitchs[tete] = pitchCourant;
|
||||
tete = (tete + 1) % HISTORIQUE;
|
||||
if (taille < HISTORIQUE) taille++;
|
||||
}
|
||||
aRegard = true;
|
||||
tickCourant = Math.max(tickCourant, tick);
|
||||
yawCourant = yaw;
|
||||
pitchCourant = pitch;
|
||||
|
||||
if (!enAttente) return 0;
|
||||
if (tick > limite) {
|
||||
@@ -57,8 +71,7 @@ public final class RotationSilencieuse {
|
||||
|
||||
/** Un coup est porté au tick donné, avec le dernier regard reçu. */
|
||||
public void coup(long tick) {
|
||||
if (taille == 0) return;
|
||||
int dernier = Math.floorMod(tete - 1, HISTORIQUE);
|
||||
if (!aRegard || taille == 0) return;
|
||||
int reference = -1;
|
||||
for (int k = 1; k <= taille; k++) {
|
||||
int i = Math.floorMod(tete - k, HISTORIQUE);
|
||||
@@ -68,12 +81,12 @@ public final class RotationSilencieuse {
|
||||
}
|
||||
}
|
||||
if (reference < 0) return;
|
||||
if (angle(yaws[reference], pitchs[reference], yaws[dernier], pitchs[dernier]) < SNAP_DEGRES) return;
|
||||
if (angle(yaws[reference], pitchs[reference], yawCourant, pitchCourant) < SNAP_DEGRES) return;
|
||||
enAttente = true;
|
||||
avantYaw = yaws[reference];
|
||||
avantPitch = pitchs[reference];
|
||||
coupYaw = yaws[dernier];
|
||||
coupPitch = pitchs[dernier];
|
||||
coupYaw = yawCourant;
|
||||
coupPitch = pitchCourant;
|
||||
limite = tick + DELAI_TICKS;
|
||||
}
|
||||
|
||||
@@ -90,6 +103,8 @@ public final class RotationSilencieuse {
|
||||
public void vider() {
|
||||
taille = 0;
|
||||
tete = 0;
|
||||
aRegard = false;
|
||||
tickCourant = 0;
|
||||
enAttente = false;
|
||||
}
|
||||
}
|
||||
@@ -487,4 +487,21 @@ class AuditFaillesTest {
|
||||
}
|
||||
assertTrue(vu, "bateau à 8 blocs/tick sur la glace : vu");
|
||||
}
|
||||
|
||||
/** Revue de sécurité de F11 : dix paquets de rotation par tick avant le coup ne chassent plus le regard de référence. */
|
||||
@Test
|
||||
void F11_inondation_de_rotations_vue() {
|
||||
boolean vu = false;
|
||||
for (int tick = 0; tick < 200; tick++) {
|
||||
long now = tick * 50L;
|
||||
int phase = tick % 7;
|
||||
if (phase == 2 || phase == 3) {
|
||||
for (int k = 0; k < 10; k++) vu |= contient(moteur.regard(j, now, EtatJoueur::normal, 90f, 0f), Controle.ROTATION);
|
||||
if (phase == 3) moteur.attaque(j, now, EtatJoueur.normal(), 0.0, 100 + tick % 3, true);
|
||||
} else {
|
||||
vu |= contient(moteur.regard(j, now, EtatJoueur::normal, 0f, 0f), Controle.ROTATION);
|
||||
}
|
||||
}
|
||||
assertTrue(vu, "rotation vers la cible sur deux ticks inondés de paquets, coup, retour : vu");
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur