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>
Cette révision appartient à :
1 Parent
ba37380d8e
révision
4d21404bcd
5 fichiers modifiés
+133
-35
Aucun fichier ne correspond à votre recherche
@@ -429,7 +429,7 @@ public final class Garde {
|
|||||||
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
||||||
MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ());
|
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).
|
// 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);
|
List<Verdict> v = verdictsInteraction(p, pos, face, null, -1);
|
||||||
Sanction s = traiter(p, v);
|
Sanction s = traiter(p, v);
|
||||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||||
}
|
}
|
||||||
@@ -439,16 +439,16 @@ public final class Garde {
|
|||||||
* en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici. Câblage non testé en jeu.
|
* 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,
|
public static boolean noterInteractionBloc(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
||||||
net.minecraft.world.phys.Vec3 impact) {
|
net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) {
|
||||||
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return false;
|
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return false;
|
||||||
List<Verdict> v = verdictsInteraction(p, pos, face, impact);
|
List<Verdict> v = verdictsInteraction(p, pos, face, impact, mainPrincipale ? 0 : 1);
|
||||||
Sanction s = traiter(p, v);
|
Sanction s = traiter(p, v);
|
||||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||||
return Cablage.sanctionDeMouvement(s);
|
return Cablage.sanctionDeMouvement(s);
|
||||||
}
|
}
|
||||||
|
|
||||||
private static List<Verdict> verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
private static List<Verdict> verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face,
|
||||||
net.minecraft.world.phys.Vec3 impact) {
|
net.minecraft.world.phys.Vec3 impact, int main) {
|
||||||
if (CONFIG.mode(Controle.INTERACTION_BLOC) == Mode.OFF || estExempteManuellement(p.getUUID())) return List.of();
|
if (CONFIG.mode(Controle.INTERACTION_BLOC) == Mode.OFF || estExempteManuellement(p.getUUID())) return List.of();
|
||||||
net.minecraft.world.level.Level l = p.level();
|
net.minecraft.world.level.Level l = p.level();
|
||||||
BlockState st = l.getBlockState(pos);
|
BlockState st = l.getBlockState(pos);
|
||||||
@@ -461,7 +461,7 @@ public final class Garde {
|
|||||||
deplacement = Math.sqrt(Math.pow(m.oeilDernier[0] - m.oeilAvant[0], 2) + Math.pow(m.oeilDernier[1] - m.oeilAvant[1], 2)
|
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));
|
+ Math.pow(m.oeilDernier[2] - m.oeilAvant[2], 2));
|
||||||
}
|
}
|
||||||
return MOTEUR.interactionBloc(p.getUUID(), p.server.getTickCount() * 50L, pos.asLong(), etat(p, true),
|
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},
|
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},
|
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);
|
st.isAir(), st.isCollisionShapeFullBlock(l, pos), p.blockInteractionRange(), deplacement);
|
||||||
|
|||||||
@@ -151,13 +151,15 @@ public final class GardeEvents {
|
|||||||
|
|
||||||
/**
|
/**
|
||||||
* 0.5 (P2.5) : clic droit sur un bloc, les deux mains (un client forgé peut n'envoyer que la main secondaire). Le
|
* 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 : dédoublonné par le moteur.
|
* 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)
|
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||||
public static void onClicDroitBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.RightClickBlock event) {
|
public static void onClicDroitBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.RightClickBlock event) {
|
||||||
if (event.getLevel().isClientSide()) return;
|
if (event.getLevel().isClientSide()) return;
|
||||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||||
if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation())) {
|
if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation(),
|
||||||
|
event.getHand() == net.minecraft.world.InteractionHand.MAIN_HAND)) {
|
||||||
event.setCanceled(true);
|
event.setCanceled(true);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -76,15 +76,50 @@ public final class InteractionBloc {
|
|||||||
return 2.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 dernierMs = Long.MIN_VALUE;
|
||||||
private long derniereCle = 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;
|
||||||
|
|
||||||
/** Même instant et même bloc que l'interaction précédente (l'autre main du même clic) : vrai, à ne pas compter. */
|
/** Anomalie du dernier événement évalué (null si aucune). */
|
||||||
public boolean doublon(long nowMs, long cleBloc) {
|
public String derniereAnomalie() {
|
||||||
boolean d = nowMs == dernierMs && cleBloc == derniereCle;
|
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;
|
dernierMs = nowMs;
|
||||||
derniereCle = cleBloc;
|
derniereCle = cleBloc;
|
||||||
return d;
|
derniereMain = main;
|
||||||
|
derniereFace = face;
|
||||||
|
dernierImpact = impact == null ? null : impact.clone();
|
||||||
|
derniersVerdicts = java.util.List.copyOf(verdicts);
|
||||||
}
|
}
|
||||||
|
|
||||||
public int dernierCompte() {
|
public int dernierCompte() {
|
||||||
|
|||||||
@@ -527,27 +527,36 @@ public final class Moteur {
|
|||||||
*/
|
*/
|
||||||
public List<Verdict> interactionBloc(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] boite, int face,
|
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) {
|
double[] impact, boolean air, boolean plein, double portee, double deplacement) {
|
||||||
return interactionBloc(joueur, nowMs, Long.MIN_VALUE, etat, oeil, boite, face, impact, air, plein, portee, 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}) : deux interactions au même instant sur le même bloc (main
|
* Idem, avec la position du bloc ({@code BlockPos.asLong}) et la main (0 principale, 1 secondaire, -1 inconnue).
|
||||||
* principale puis secondaire du même clic) ne comptent qu'une fois. {@code Long.MIN_VALUE} = pas de dédoublonnage.
|
* 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, EtatJoueur etat, double[] oeil, double[] boite,
|
public List<Verdict> interactionBloc(UUID joueur, long nowMs, long cleBloc, int main, EtatJoueur etat, double[] oeil,
|
||||||
int face, double[] impact, boolean air, boolean plein, double portee, double deplacement) {
|
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();
|
if (expulses.contains(joueur) || cfg.mode(Controle.INTERACTION_BLOC) == Mode.OFF) return List.of();
|
||||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||||
if (ex.exempt()) return List.of();
|
if (ex.exempt()) return List.of();
|
||||||
Suivi s = suivi(joueur);
|
Suivi s = suivi(joueur);
|
||||||
if (cleBloc != Long.MIN_VALUE && s.interactionBloc.doublon(nowMs, cleBloc)) return List.of();
|
|
||||||
double marge = (cfg.interactionBlocMarge + Math.max(0, Math.min(deplacement, 5.0))) * ex.facteur();
|
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);
|
String a = InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, portee, marge);
|
||||||
|
// 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);
|
double pts = s.interactionBloc.enregistrer(nowMs, a, cfg);
|
||||||
List<Verdict> v = new ArrayList<>(1);
|
List<Verdict> v = new ArrayList<>(1);
|
||||||
ajouter(v, s, Controle.INTERACTION_BLOC, pts, nowMs, ex, String.format(Locale.ROOT,
|
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 (%s), %d anomalies sur %d interactions", a, impact == null ? "debut de casse" : "clic droit",
|
||||||
s.interactionBloc.dernierCompte(), InteractionBloc.SERIE));
|
s.interactionBloc.dernierCompte(), InteractionBloc.SERIE));
|
||||||
|
s.interactionBloc.memoriser(nowMs, cleBloc, main, face, impact, a, v);
|
||||||
return v;
|
return v;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
|
|||||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
import java.util.UUID;
|
import java.util.UUID;
|
||||||
import org.junit.jupiter.api.Test;
|
import org.junit.jupiter.api.Test;
|
||||||
|
|
||||||
@@ -96,26 +97,77 @@ class InteractionBlocP2Test {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/** Revue de sécurité : la main secondaire seule est mesurée ; les deux mains d'un même clic comptent une fois. */
|
// --- 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
|
@Test
|
||||||
void mainSecondaireCompteeEtDoublonsIgnores() {
|
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);
|
Moteur m = new Moteur(cfg);
|
||||||
double pts = 0;
|
|
||||||
int verdicts = 0;
|
|
||||||
for (int i = 0; i < 3; i++) {
|
|
||||||
// clic forgé en main secondaire seule (adaptateur : même appel quelle que soit la main), sur de l'air
|
|
||||||
for (Verdict v : m.interactionBloc(joueur, i * 500L, 100L + i, EtatJoueur.normal(), new double[] {0.5, 66.62, 2},
|
|
||||||
CUBE, HAUT, new double[] {0.5, 65, 0.5}, true, true, 4.5, 0)) pts += v.points();
|
|
||||||
}
|
|
||||||
assertTrue(pts > 0, "3 clics d'une seule main suffisent");
|
|
||||||
Moteur m2 = new Moteur(cfg);
|
|
||||||
for (int i = 0; i < 2; i++) {
|
for (int i = 0; i < 2; i++) {
|
||||||
for (int main = 0; main < 2; main++) { // principale puis secondaire, même tick, même bloc
|
clic(m, i * 500L, 7L, 0, HAUT, IMPACT, true);
|
||||||
verdicts += m2.interactionBloc(joueur, i * 500L, 7L, EtatJoueur.normal(), new double[] {0.5, 66.62, 2},
|
clic(m, i * 500L, 7L, 1, HAUT, IMPACT, true);
|
||||||
CUBE, HAUT, new double[] {0.5, 65, 0.5}, true, true, 4.5, 0).size();
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
assertEquals(0, verdicts, "2 clics (4 événements) : 2 anomalies comptées, sous la série de 3");
|
assertEquals(2, m.suivi(joueur).interactionBloc.dernierCompte(), "2 clics (4 événements) = 2 anomalies");
|
||||||
assertTrue(m2.suivi(joueur).interactionBloc.dernierCompte() == 2);
|
// 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");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Référencer dans un nouveau ticket
Bloquer un utilisateur