VirgolaAntiCheat v1.6.2

VirgolaAntiCheat — Changelog v1.0.1 (Refactoring Checks)
This update focuses entirely on check accuracy: reducing false positives, fixing logical bugs, and adding proper handling for every legit edge case.

Bug fixes (critical)

• TimerCheck / AutoClickerCheck — double-counting: The dispatcher was incrementing movePacketsWindow and swingTimes and the checks were doing it again. Each packet was being counted twice, halving effective thresholds. Fixed: the dispatcher is now the sole owner of swing timestamps; TimerCheck is the sole owner of the move-packet window.
• FastBreakCheck — wrong-block false positive: The old check used a global lastBlockDamageMs timestamp. If a player hit block A and then instantly broke block B (which was already at 0 hardness), it would flag. Fixed: the dispatcher now stores the actual damaged block; the check verifies the broken block is the same one that was being mined.
• BlinkCheck — false positive after teleport: lastPacketMoveMs was never reset on teleport/respawn, causing the blink timer to fire right after any server-side teleport. Fixed: dispatcher resets the timestamp on every TELEPORT and RESPAWN event.
• AutoClickerCheck / ClickPatternCheck — config never loaded: The thresholds: subsection in checks.yml used wrong keys; values were never actually read, so checks ran on hardcoded defaults silently. All keys have been realigned.
• ScaffoldCheck / VelocityCheck / InventoryWalkCheck / SpeedCheck / KillAuraCheck / IllegalRotationCheck: Multiple config key mismatches between code and YAML caused settings to be ignored. All fixed and documented in checks.yml.

Legit-case improvements (all 16 checks)

• Ping/TPS tolerance: Every check now calls ctx.marginFromPingTps(player) to widen thresholds proportionally on high-latency or laggy-server conditions.
• Grace periods: Join burst (2–3 s) and post-teleport burst (1–1.5 s) are skipped globally where relevant.
• FlyCheck: Now accounts for Slow Falling and Levitation potions, climbable surfaces (ladders, vines, scaffolding, powder snow), and water/lava immersion.
• NoFallCheck: Extended safe-block list (honey, slime, berry bushes, hay bales, cobwebs, all vine variants, powder snow). Slow Falling potion skipped.
• JesusCheck: Fixed water-surface detection (was using incorrect Y-fraction math). Added Frost Walker boot detection and Dolphin's Grace potion check.
• SpeedCheck: Skips ice, slime, water, lava, and climbable blocks. Correctly applies Speed potion formula (+0.09 per level). Knockback exclusion window.
• VelocityCheck: Now measures cumulative horizontal distance from the knockback origin (not per-tick delta), with a minimum delay before checking to avoid flagging the first tick of flight.
• KillAuraCheck: Fixed target-switch window (was resetting on every non-matching target instead of on window expiry). Dynamic hitbox center via entity.getHeight().
• ReachCheck: Dynamic hitbox center, creative mode reach (5.0 blocks), same-world validation.
• FastBreakCheck: Haste potion and Efficiency enchantment correctly reduce the minimum break time. Hard floor at 40 ms (physical TPS limit).
• ScaffoldCheck: Combined consecutive-block sequencing with horizontal-speed gate to eliminate false positives on manual builders.
• IllegalRotationCheck: Delta check enabled by default with realistic thresholds (175°/90° per packet). Skips vehicles and swim mode.

Config (checks.yml) All keys have been audited and corrected. Each check section now matches exactly what the code reads, with sane defaults and inline comments explaining every parameter.

New Anticheat implementation. Read description for the new informations

Changelog (Spigot-ready)​

Update – Core Checks Improvements


In questo update ho continuato a rifinire i controlli principali per rendere i rilevamenti più coerenti, più “vanilla-like” e più affidabili nel gameplay reale, riducendo al minimo i falsi positivi senza perdere copertura sui cheat più comuni.

Updated Checks​

• FastBreak
  • Migliorata la precisione nel distinguere rotture legittime rapide da accelerazioni artificiali.
  • Gestione più robusta dei casi “borderline” e delle rotture anomale (es. blocchi che si rompono quando il player non sta più scavando).
  • Comportamento più universale e consistente su più blocchi e condizioni.
• Speed
  • Maggiore stabilità e coerenza in condizioni reali di movimento (sprint, salto, superfici particolari, ecc.).
  • Ridotte segnalazioni inutili e migliorata la lettura delle situazioni legittime più comuni.
• Jesus
  • Migliore distinzione tra comportamento illegittimo sull’acqua e situazioni legittime.
  • Rilevamento più stabile in contesti variabili.
• NoFall
  • Revisione generale per valutare meglio le condizioni legittime in cui il danno da caduta può essere ridotto o annullato.
  • Maggiore accuratezza nei casi reali senza perdere efficacia contro bypass evidenti.
• Fly
  • Migliorata la stabilità del controllo e ridotti errori in situazioni che alterano la fisica del player.
  • Meno falsi positivi su movimenti strani ma legittimi.
• InventoryWalk
  • Maggiore coerenza nel rilevare movimento durante l’interazione con GUI non compatibili con il movimento.
  • Ridotte segnalazioni inutili e migliorata l’affidabilità generale.

Work in progress​

Sto continuando a lavorare con calma e attenzione per sistemare anche i check rimanenti, evitando tuning “aggressivi” che potrebbero causare falsi positivi:


AutoClicker, FastPlace, KillAura, Reach


Se notate comportamenti strani, falsi positivi o casi non rilevati, lasciate un commento con dettagli e contesto (cheat, situazione, ping/TPS se possibile). I feedback mi aiutano tantissimo a migliorare il plugin.

Changelog (Spigot-ready)​

Update – Core Checks Improvements


This update focuses on improving the main checks to make detections more consistent, more “vanilla-like”, and more reliable in real gameplay, reducing false positives while keeping strong detection coverage.

Updated Checks​

• FastBreak
  • Improved accuracy when separating legitimate fast mining from artificial acceleration.
  • Better handling of borderline scenarios and abnormal break behavior (e.g., blocks breaking after the player stops mining).
  • More universal and consistent behavior across blocks and conditions.
• Speed
  • Improved stability and consistency in real movement scenarios (sprint, jump, special surfaces, etc.).
  • Reduced unnecessary flags and improved handling of common legit cases.
• Jesus
  • Better distinction between illegitimate water-walking and legit gameplay situations.
  • More stable detection in variable environments.
• NoFall
  • General revision to better evaluate legit conditions where fall damage can be reduced or avoided.
  • Higher accuracy in real scenarios while still catching obvious bypasses.
• Fly
  • Improved stability and fewer false flags in situations that affect player physics.
  • More reliable detection on unusual-but-legit movement patterns.
• InventoryWalk
  • More consistent detection of movement while interacting with GUIs that normally prevent movement.
  • Reduced unnecessary flags and improved overall reliability.

Work in progress​

I’m still working carefully on the remaining checks, focusing on safe tuning to avoid false positives:


AutoClicker, FastPlace, KillAura, Reach


If you notice false positives, missed detections, or strange behavior, please leave a comment with details and context (cheat used, situation, ping/TPS if possible). Feedback helps a lot to improve the plugin.

Changelog (Italiano) — VirgolaAntiCheat​

Panoramica aggiornamento​

Questa release è un refactor strutturale + rework di alcuni check con l’obiettivo di:

• ridurre falsi positivi (FP),
• rendere i check più consistenti tra loro,
• centralizzare integrazione (messaggi, log, warning, notify, config),
• rendere il tuning più semplice tramite checks.yml commentato e completo.

Sistema globale (messaggi, config, gestione eventi)​

Nuovo standard di gestione alert / log / notify​

Tutti i check interessati sono stati riallineati ad un formato unico e coerente:

• Messaggi via MessageManager con placeholders (player, check, details, valori tecnici ecc.)
• Alert staff centralizzati via AlertUtils (async dove possibile)
• ActionBar via ActionBarUtils
• Log coerente via LogManager usando generic.log-format
• Warning tramite InfractionManager (valore configurabile per check)
• Notifica al player tramite OffenderNotifyUtils.notifyDetect(...) (dove previsto)
• Cooldown anti-spam per alert staff configurabile per check

Nota: in diversi check la logica non cambia, ma cambia tutto ciò che sta “intorno” (messaggi, log, warning, notify, scheduling), così da avere comportamento uniforme e facile da debuggare.

Click to expand...

checks.yml potenziato (versatilità + commenti)​

• Aggiornato checks.yml con commenti in inglese per ogni singolo parametro
• Rimossi parametri obsoleti e aggiunti quelli mancanti per allineare i nuovi check
• Migliorata la granularità del tuning (grace, buffer/VL, decay, cap, finestre temporali, soglie, cooldown)

Check aggiornati (logica cambiata / rework)​

Scaffold — Rework completo (nuovo approccio FP-safe)​

• Eliminato l’approccio “singola prova forte” (es. raytrace come unico criterio)
• Nuova logica orientata a scaffold reale:
  • sequenze di piazzamenti coerenti sotto il player,
  • analisi in finestra temporale,
  • pattern detection con buffer/VL e decadimento,
  • filtri anti-FP (costruzione normale, piazzamenti non consecutivi, contesti legittimi)
• Parametri Scaffold aggiornati in checks.yml (nuova filosofia tuning)

InventoryWalk — Rework completo (nuovo sistema buffer/VL)​

• Rimosso l’approccio basato su singoli eventi “movimento con GUI” troppo sensibile
• Nuovo sistema FP-safe:
  • riconoscimento GUI attiva reale (inclusa la GUI inventario player quando possibile)
  • finestra “GUI open grace” per pacchetti in volo
  • buffer incrementale solo su movimento confermato
  • decay intelligente (no GUI / grace / gap / contesti rischiosi)
  • grace dopo knockback/velocity e dopo damage
  • opzione per chiudere inventario su detect (di default OFF)

KillAura + Reach — Rework / integrazione Reach dentro KillAura​

• KillAura rivisitata con un approccio più FP-safe:
  • matching pacchetto↔evento con finestre tick/ms
  • tolleranze su hitbox/ray/AABB per desync
  • gestione ping/TPS (skip check in condizioni rischiose)
  • VL con cap/decay/post-alert reduce
• Reach: rimosso come check standalone, ma mantenuti i riferimenti necessari per integrarlo dentro KillAura (incluse eccezioni legittime come tridente)

Check aggiornati (logica simile, ma integrazione nuova)​

Questi check non cambiano nel cuore della logica, ma sono stati aggiornati per essere coerenti con il nuovo sistema (messaggi/log/warning/notify/config/cooldown).

Click to expand...

🕊 Fly — Integrazione standardizzata​

• Alert e dettagli via MessageManager
• Warning e log uniformati
• Tuning completo in checks.yml con parametri VL/decay/soglie/cooldown

NoFall — Integrazione standardizzata​

• Sistema alert/log/warning/notify reso coerente con gli altri check
• Tutti i parametri rilevanti esposti in checks.yml e documentati

Jesus — Integrazione standardizzata​

• Alert/actionbar/log/warning uniformati e configurabili
• Parametri in checks.yml con commenti

Speed — Integrazione standardizzata​

• Stesso formato alert/log/warning/notify degli altri check
• Config tuning coerente (tolerance, post landing buffer, cooldown, warning)

⛏ FastBreak — Integrazione e configurazione coerente​

• Parametri di precisione e sicurezza FP esposti in checks.yml
• Sistema VL/cooldown/post-alert reduce documentato

FastPlace — configurazione espansa (preparazione al rework)​

• checks.yml aggiornato per includere tuning più completo
• Obiettivo: ridurre FP e gestire “burst” e spam legit/lag in modo controllato
  (il rework di logica viene fatto nello step successivo)

Pulizia progetto / rimozioni​

• Rimossi check inutili:
  • ClickPattern eliminato
  • Reach eliminato come check separato (resta integrato nella KillAura)
• Verificati e ripuliti riferimenti residui alle parti eliminate, mantenendo solo quelli necessari per la Reach dentro KillAura.

Nota importante (feedback richiesto)​

Questa release introduce cambiamenti profondi. Anche se l’obiettivo è FP-safe, alcuni server possono avere edge case a causa di:

• TPS fluttuante,
• ping alto,
• plugin di movimento/combat/build,
• meccaniche particolari di bridging/building.

Se riscontrate problemi, lasciate un commento su Spigot includendo:

• versione server (Paper/Spigot) + versione MC,
• TPS medio,
• ping medio,
• contesto (pvp/build/bridging),
• log del detect (se possibile).

Changelog (English) — VirgolaAntiCheat​

Update overview​

This release is a structural refactor + several check rewrites, focused on:

• reducing false positives,
• making every check consistent and easier to tune,
• centralizing integration (messages, logs, warnings, notify, config),
• improving checks.yml versatility with full English documentation.

Global system (messages, config, event handling)​

Unified alert / log / notify system​

All updated checks now follow the same integration standard:

• Messages handled by MessageManager with placeholders (player, check, details, etc.)
• Staff alerts through AlertUtils (async when possible)
• ActionBar via ActionBarUtils
• Logs standardized using LogManager + generic.log-format
• Warnings through InfractionManager (per-check configurable)
• Player notification via OffenderNotifyUtils.notifyDetect(...) (where applicable)
• Per-check cooldown to prevent alert spam

Improved checks.yml (more versatile + fully commented)​

• Updated checks.yml with English comments for every parameter
• Removed obsolete keys and added missing ones
• Much better tuning control (grace windows, buffer/VL, decay, caps, time windows, thresholds, cooldowns)

Checks updated (logic reworked)​

Scaffold — Full rewrite (FP-safe but strong)​

• Moved away from “single strong proof” logic (raytrace-only style)
• New scaffold-oriented detection:
  • consistent “under-feet” placement sequences,
  • time-window evaluation,
  • buffer/VL accumulation + decay,
  • FP filters for legit building and inconsistent patterns
• Updated Scaffold config keys in checks.yml

InventoryWalk — Full rewrite (buffer/VL system)​

• Removed overly sensitive “GUI movement = instant flag” behavior
• New FP-safe system:
  • real GUI detection (including player inventory when possible),
  • GUI open grace window to handle in-flight packets,
  • buffer gain only on confirmed movement,
  • smart decay (no GUI / grace / timing gaps / risky contexts),
  • velocity/damage grace windows,
  • optional inventory-close on detect (default OFF)

KillAura + Reach — Rewrite / Reach integrated into KillAura​

• Safer KillAura approach:
  • packet↔event matching windows (ticks/ms),
  • AABB/ray tolerances for desync,
  • ping/TPS safety skipping,
  • VL with cap/decay/post-alert reduction
• Reach removed as standalone, but kept as a module integrated inside KillAura (including legit bonuses like trident)

Checks updated (logic mostly same, integration upgraded)​

🕊 Fly — Integration standardized​

• MessageManager alerts + details
• Standard logs/warnings
• Full tuning via checks.yml (VL/decay/thresholds/cooldown)

NoFall — Integration standardized​

• Unified alert/log/warning/notify flow
• All tuning exposed and documented in checks.yml

Jesus — Integration standardized​

• Unified alerts/actionbar/log/warning
• Tunable parameters in checks.yml

Speed — Integration standardized​

• Same alert/log/warning/notify flow as other checks
• Config tuning aligned (tolerance, post landing buffer, cooldown, warning)

⛏ FastBreak — Integration + config consistency​

• Precision + FP-safety parameters exposed in checks.yml
• VL/cooldown/post-alert reduction fully documented

FastPlace — Expanded config (rework-ready)​

• checks.yml expanded to support a safer/stronger FastPlace logic
• Next step is code rework (config already ready)

Cleanup / removals​

• Removed unused checks:
  • ClickPattern removed
  • Reach removed as standalone (kept only as KillAura sub-module)
• Cleaned leftover references (keeping only Reach-related parts used by KillAura).

Important note (feedback requested)​

This update introduces deep changes. While everything is designed to be FP-safe, some server setups can still hit edge cases due to:

• unstable TPS,
• high ping,
• movement/combat/build plugins,
• unusual bridging/build patterns.

Please comment on the Spigot page if you find issues, including:

• server software + MC version,
• average TPS,
• average ping,
• context (pvp/build/bridging),
• detect logs if possible.

Changelog (completo – Spigot-ready)
CORE / SISTEMA

Unificazione comandi: sostituiti i vecchi comandi separati con una classe unica AcCommand che gestisce i sottocomandi (es. /ac stats <player>, /ac gui, ecc.).

Logging centralizzato: integrato LogManager in listener/check per registrare eventi in modo uniforme.

Anti-spam alert: implementato un sistema centralizzato di cooldown (AlertCooldownManager) per prevenire flood di alert ripetuti in rapida sequenza.

Supporto ProtocolLib (quando disponibile): alcuni check usano pacchetti per una lettura più precisa; fallback su eventi Bukkit quando ProtocolLib non è presente.

CHECKS (modificati con successo)
Speed (rework)

Modello di rilevazione basato su distanza orizzontale per finestra di tick (più stabile di “blocchi/secondo”).

Tick counter server-side per calcoli coerenti.

Sistema Violation Level (VL) con accumulo prudente + decay per ridurre FP.

Grace windows anti-FP per:

Teleport / Respawn / Cambio mondo (reset + grace)

Velocity/knockback (grace dinamica in base alla spinta)

Danni (buffer per esplosioni/colpi)

Considerate molte condizioni legit (sprint/sneak, pozioni speed/slowness, superfici: ice/slime/honey/soul sand/soil + soul speed/cobweb/berries/powder snow, buffer salto, buffer verticale).

Alert più chiari: Distance vs AllowedDistance con dettagli opzionali.

FastBreak (hardening + timing più affidabile)

Timing reso più “server authoritative”:

START da ProtocolLib START_DESTROY_BLOCK (o fallback BlockDamageEvent)

END su BlockBreakEvent (server certo)

STOP packet non usato per misurare (troppo rumoroso)

Riduzione FP con filtri robusti:

Ignora blocchi “instant/soft” sotto min_hardness

Ignora sample ambigui (dtTicks <= 0)

Ignora lag eccessivo (max_dt_ticks)

START/BREAK devono corrispondere allo stesso blocco (BlockKey)

Cleanup start “appesi” (start_expire_ticks)

Expected time migliorato (più vanilla-like e combinabile):

Efficiency, Haste, Mining Fatigue

Penalità underwater senza Aqua Affinity

Penalità airborne (!onGround)

Harvestability basata su drops reali (block.getDrops(tool)), più corretta di euristiche

CHECKS “IN REVISIONE” (toccati ma non ancora chiusi)
Jesus

Aggiunte molte protezioni anti-falsi positivi (edge detection, corner sampling hitbox, grace dopo fluid/teleport, esclusione veicoli/superfici legit).

Problema attuale: con le protezioni attuali non produce detect affidabili (troppo conservativo) → richiede ulteriore tuning per mantenere “zero FP” ma rilevare realmente il cheat.

Speed (rifiniture richieste)

Problemi segnalati:

detect non sempre immediato

possibile “detect di coda” subito dopo lo stop del cheat

gestione liquidi migliorabile (non indispensabile, ma utile)

FastBreak (edge cases)

Problemi segnalati: restano alcuni falsi positivi su casistiche specifiche → serve ulteriore affinamento del calcolo expected / condizioni ambientali.

Changelog (complete – Spigot-ready)
CORE / SYSTEM

Command unification: replaced separate command classes with a single AcCommand handling subcommands (e.g. /ac stats <player>, /ac gui, etc.).

Centralized logging: integrated LogManager across listeners/checks for consistent logging.

Anti-alert spam: implemented a centralized cooldown system (AlertCooldownManager) to prevent rapid alert flooding.

ProtocolLib support (when available): some checks leverage packet-level data for higher precision, with Bukkit-event fallback when ProtocolLib is missing.

CHECKS (successfully updated)
Speed (full rework)

Detection model rebuilt using horizontal distance per tick window (more stable than raw “blocks per second”).

Server-side tick counter for consistent timing.

Conservative Violation Level (VL) accumulation + decay to reduce false positives.

Anti-FP grace windows for:

Teleport / Respawn / World change (reset + grace)

Velocity/knockback (dynamic grace based on applied velocity)

Damage events (explosions/hits buffer)

Many legit conditions accounted for (sprint/sneak, speed/slowness potions, surfaces: ice/slime/honey/soul sand/soil + soul speed/cobweb/berries/powder snow, jump inertia buffer, vertical buffer).

Clearer alerts: Distance vs AllowedDistance with optional detail info.

FastBreak (hardening + more reliable timing)

More server-authoritative timing:

START from ProtocolLib START_DESTROY_BLOCK (or BlockDamageEvent fallback)

END measured on BlockBreakEvent (server authoritative)

STOP packet not used for timing (too noisy)

Strong FP reduction filters:

Ignore instant/soft blocks under min_hardness

Ignore ambiguous samples (dtTicks <= 0)

Ignore extreme lag samples (max_dt_ticks)

Strict START/BREAK same block validation (BlockKey)

Stale start cleanup (start_expire_ticks)

Improved expected-time calculation (more vanilla-like, stackable):

Efficiency, Haste, Mining Fatigue

Underwater penalty without Aqua Affinity

Airborne penalty (!onGround)

Harvestability based on real drops (block.getDrops(tool)), more accurate than heuristics

CHECKS “IN REVIEW” (touched but not fully resolved yet)
Jesus

Added multiple false-positive protections (edge detection, hitbox corner sampling, post-fluid/teleport grace, vehicle/legit surface exclusions).

Current issue: with current safeguards it does not reliably detect Jesus/water-walk (too conservative) → needs further tuning to keep “zero FP” while catching the cheat.

Speed (requested refinements)

Reported issues:

detection not always immediate

possible “tail detection” right after disabling cheat

liquid handling could be improved

FastBreak (edge cases)

Reported issues: some false positives still occur in specific scenarios → further refinement needed for expected-time/conditions.

AntiCheat Update – What’s New​

FastBreak​

• Fixed false flags when breaking soft or instant-mine blocks.
• More accurate tool + enchantment detection.
• Less spammy alerts.

Fly​

• Fixed false flags when sprinting or jumping.
• More tolerance when falling or using Slow Falling potion.
• Safer detection around blocks like slime, honey, and ladders.

KillAura​

• Better detection of impossible hits.
• Much fewer false positives during normal PvP.
• Smarter aim checks, tuned closer to vanilla limits.

Jesus​

• Fixed false flags when walking on the edge of water blocks.
• No more alerts if you’re on a boat, strider, minecart, or legit blocks like lilypads and ice.
• Works with or without ProtocolLib.

Overall: The system is now smarter, less aggressive, and fairer. Legit gameplay (PvP, parkour, boats, etc.) won’t trigger false alerts, while cheats are still caught.

Changelog - 10.08.2025
Core / Architecture

• Asynchronous initialization of managers (whitelist, checks, messages) to reduce main thread load during startup.
  
  
• Streamlined listener registration: each check registers safely and independently.
  
  
• ProtocolLib fallback: packet-based detection where available, Bukkit event fallback otherwise.
  
  
• Thread-safety: all Bukkit/Spigot calls moved to the main thread; in-memory states use concurrent maps.
  
  
• Optional WorldGuard hook: safe detection that won’t break the plugin if WG is missing, with modern/legacy API support.

WorldGuard (Safe Integration)

• Added WorldGuardHook with autodiscovery:
  • If WG is missing → integration is skipped silently.
    
    
  • If present → provides safe access to region/flag checks.
• SafeIntegration utility to skip checks when block breaking/placing is denied by region flags (avoids false positives in protected areas).

KillAura

• Rebuilt structure: captures player data on the main thread, performs geometric calculations asynchronously (ray vs AABB, dot product, angle, yaw).
  
  
• Dynamic tolerances (ping/TPS-aware) and “hard cases” (out-of-FOV or behind hits) trigger certain alerts.
  
  
• Anti-spam cooldown, consistent actionbar/logging system.
  
  
• Debugging tools implemented for tuning and removed in the clean build.

Fly

• AirTicks/hover/ascend logic with proper resets (solid/liquid/climbable, cobweb/powder snow support).
  
  
• Handling Levitation (whitelisted) and Slow Falling (adaptive threshold instead of bypass).
  
  
• Checks on fallDistance and velocity Y to detect legitimate falls and avoid false positives.
  
  
• Support for POSITION/POSITION_LOOK packets with Bukkit PlayerMoveEvent fallback.
  
  
• Optimizations: localized block scans, per-player counters, thread-safe state.

Reach

• Uses ProtocolLib (USE_ENTITY) to capture the actual hit target, with EntityDamageByEntityEvent fallback.
  
  
• Stable eye-to-eye reach distance calculation, configurable thresholds, and cooldown system.
  
  
• Lightweight structure, minimal state tracking, no off-thread Bukkit calls.
  
  
• Reduced false positives on borderline hits; messaging/infraction/logging standardized.

FastBreak

• Added region/flag check: if a block cannot be broken due to protection, it’s excluded from detection.
  
  
• Hybrid packet + event approach:
  • Packet BLOCK_DIG for precise timing (start/stop/abort).
    
    
  • Bukkit BlockBreakEvent fallback for safety.
• Calculates expected break time considering tool type, Efficiency enchantment, Haste/Fatigue effects, and block hardness.
  
  
• Cooldowns, optional detailed logs, unified logging format.

FastPlace

• Packet USE_ITEM_ON with baseline: the first valid placement creates history and is not checked (avoids instant alerts).
  
  
• Only successful placements (non-cancelled events) are counted, excluding protected regions/flags.
  
  
• Flag conditions:
  • Rapid (< min_interval_ms between consecutive valid places).
    
    
  • Nearby (distance between placed blocks < threshold) to detect scaffolding/drag placement.
• Anti-spam cooldown, optional detailed logs, unified logging format.
  
  
• Fallback to BlockPlaceEvent when ProtocolLib is unavailable.

Config / checks.yml

• Updated and documented parameters for:
  • KillAura (FOV/dot, yaw, reach hard, tolerances).
    
    
  • Fly (max fall speed, air ticks, slow falling multiplier, fall thresholds).
    
    
  • Reach (max reach, cooldown, warning amount).
    
    
  • FastBreak (cooldown, warning; WG safe).
    
    
  • FastPlace (min interval, distance, cooldown, warning; baseline & WG safe).
• Provided clear English descriptions for each parameter with “higher/lower value” effect notes.

Messaging & Logging

• Unified message keys (alerts., actionbar., generic.*) and variable placeholders {player}, {details}, etc.
  
  
• Async alerts and actionbar updates, with generic log format including detailed variables for audit clarity.

Performance

• Heavy computations (geometry, validations) offloaded to async threads.
  
  
• ConcurrentHashMap for per-player state tracking.
  
  
• Bukkit/Spigot API calls executed only on the main thread (scheduled).
  
  
• Localized block scans; no heavy world entity iterations.

Changelog — 10.08.2025​

Highlights​

• KillAura check fully reworked for accuracy and performance: main-thread safety, robust entity resolution with ProtocolLib, adaptive hitbox edge tolerance, and async alert pipeline aligned with NoFall.
• Safety fixes for async Bukkit usage (no more “Asynchronous Chunk getEntities”).
• Better false-positive control (especially for borderline hits and powder snow/edge cases across checks).
• Config clarity: cleaned up and documented checks.yml parameters (English keys + how they affect strictness).
• Performance: reduced allocations, batched config reads with lightweight caching, zero unnecessary thread switching.

Combat — KillAura​

Major refactor and reliability improvements

• Rebuilt the check to detect suspicious hits when the player is not actually looking at the target’s hitbox, with:
  • Ray vs AABB intersection test (hard rule).
  • Soft look checks (look dot, angle, yaw difference).
  • Hard FOV gate (extreme out-of-view hits trigger definite alert).
• Adaptive edge tolerance for “borderline” hits:
  If the player’s aim is very good (high dot / low angle), the check allows a larger miss tolerance on the eye→reach segment distance. This significantly reduces false positives for legit near-edge hits.
• Main-thread safe entity resolution (via Bukkit.getScheduler().runTask inside USE_ENTITY handler).
  Fixes the Paper error: “Asynchronous Chunk getEntities call”.
• Packet look cache: captures yaw/pitch from LOOK/POSITION_LOOK packets for more accurate angles, with low overhead.
• ProtocolLib fallback: if entity use action can’t be read, the system gracefully falls back to EntityDamageByEntityEvent.
• Async alert flow (modeled after NoFall):
  Off-thread alert broadcast + logging, then main-thread actionbar + warning addition + player message.
• Zero debug noise by default; clean console.
• Performance-first design: no heavy allocations, minimal math helpers, tiny configuration cache with periodic refresh.

New / adjusted config keys (in checks.yml > KillAura):

• enabled — turn the check on/off.
• min_look_dot — higher = stricter.
• max_look_angle — lower = stricter.
• max_yaw_diff — lower = stricter.
• close_distance_always_allow — allow very close melee scrums.
• hard_reach — ray length. Slightly increased default to reduce FPs on edges.
• hard_fov_deg — immediate fail if exceeded.
• aabb_expand — expands target hitbox slightly to reduce edge FPs.
• ray_miss_tolerance — base tolerance for the ray “miss distance”. Now combined with adaptive tolerance (better aim → more tolerance).
• cooldown_ms — per-player alert cooldown.
• warning_amount — points added per alert.

(We also provided English descriptions for all keys so you can tune strictness safely.)

Movement — Speed (quality updates)​

• Added safeguards to avoid speed alerts during legitimate teleports/warps (small grace when server forcibly sets position).
• Powder Snow handling improved to avoid false positives when walking/falling through it (slow descent / friction cases).
• Cleaned and optimized the check loop (fewer config lookups, minor math/logic tweaks) without changing your original logic.

Movement — NoFall​

• Introduced grace periods for legit scenarios: login, respawn, teleport, and other forced position changes.
  Prevents accidental NoFall alerts when the server resets the player’s position or flags.
• Kept your original logic, refactoring for lower overheadand safer async/main-thread boundaries:
  • Packet-level fall tracking separated from Bukkit event path.
  • Asynchronous alert dispatch + main-thread UI/warning commit (consistent with KillAura).
  • Periodic cleanup of in-memory maps to prevent leaks.

Commands & Messages​

• Toggle messages: corrected formatting and color application behavior so the prefix and state color display properly at the start of the message.
• MessageManager now translates color codes early and safely returns prefixed strings with color preserved (even at the beginning).

Stability & Performance​

• Eliminated unsafe async calls into Bukkit/Spigot/Paper API.
  (e.g., entity/world access strictly on the main thread.)
• Reduced allocations (no temporary objects where not necessary) and limited config reads using lightweight parameter caching with periodic refresh (~1.5s).
• Clear separation of lightweight math (main thread) and background tasks (logging/alert broadcasting).

Migration tips​

1. Replace the JAR with the new build.
2. Delete the plugin data folder to let the plugin re-generate configs and internal structures.
3. If you had custom changes, copy your previous edits into the newly generated configs (keys and defaults changed/expanded in places).
4. Adjust KillAura thresholds gradually if needed:
   • Too many false positives → increase aabb_expand (e.g., 0.08–0.10), raise ray_miss_tolerance (e.g., 0.24–0.30), raise max_look_angle, or lower min_look_dot.
   • Too lenient → reduce ray_miss_tolerance, aabb_expand, hard_fov_deg, or increase min_look_dot.