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.

⚙️ 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).

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.

⚔️ 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 overhead and 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.

Update Changelog

• Improved InventoryWalk check:
  
  • Added tolerance for pushes from other entities to reduce false positives.
    
    
  • Automatically closes the inventory when the player receives any type of damage.
    
    
  • Optimized movement detection to avoid triggering alerts when the player is only pushed slightly.
    
    
  • Enhanced ProtocolLib + Bukkit event compatibility for better accuracy across all supported versions.
    
• General optimizations:
  
  • Improved performance by reducing redundant checks and asynchronous scheduling overhead.
    
    
  • More consistent cooldown handling to prevent alert flooding.
    

Update Changelog

• Improved InventoryWalk check:
  
  • Added tolerance for pushes from other entities to reduce false positives.
    
    
  • Automatically closes the inventory when the player receives any type of damage.
    
    
  • Optimized movement detection to avoid triggering alerts when the player is only pushed slightly.
    
    
  • Enhanced ProtocolLib + Bukkit event compatibility for better accuracy across all supported versions.
    
• General optimizations:
  
  • Improved performance by reducing redundant checks and asynchronous scheduling overhead.
    
    
  • More consistent cooldown handling to prevent alert flooding.
    

Global Improvements & Bug Fixes:

• False Positive Reduction:
  All checks now distinguish between real cheating attempts and legitimate player actions, drastically reducing false positives.
  
  
• Performance Optimization:
  Switched to thread-safe data structures (ConcurrentHashMap, etc.), and offloaded heavy checks to async tasks wherever possible for better server performance.
  
  
• Config-Driven:
  All thresholds, cooldowns, warning amounts, and detection parameters are now fully configurable via ChecksConfig.
  
  
• Consistent Messaging & Logging:
  Improved alert, action bar, warning, and log messages with more detailed placeholders for easy debugging.
  
  
• Bypass Handling:
  Players with the bypass permission or in Creative/Spectator mode are always correctly excluded from checks.
  
  
• Better Thread Safety:
  All shared state is properly synchronized.
  

InventoryWalkCheck

• No more alerts for inventory interaction or head movement:
  Detection now triggers only if the player actually walks (moves in X/Z coordinates) with the GUI open, not just by moving their view or interacting with inventory slots.
  
  
• Buffer after inventory open:
  Added an 850ms buffer after opening inventory to prevent instant false alerts.
  
  
• Packet-based precision:
  When ProtocolLib is available, movement is tracked directly at the packet level for maximum accuracy.
  
  
• Less spam:
  Alert cooldown and GUI open buffer fully configurable.
  

NoFallCheck

• Dual-Mode Detection (Events + ProtocolLib):
  The check works both with Bukkit events and ProtocolLib packets for maximum compatibility and accuracy.
  
  
• Accurate Fall Distance:
  Accumulates real fall distance, considers boots with Feather Falling and Slow Falling effect, and never triggers for falls onto safe blocks (water, slime, ladders, vines, boats, minecarts, etc.).
  
  
• False positive reduction:
  Properly resets fall state on safe landing, disables itself when needed, and avoids alerting when players take legitimate no-damage falls.
  
  
• Async computation:
  All heavy calculations and alerts happen async, reducing main thread lag.
  

FastBreakCheck

• Accurate Break Time Calculation:
  Checks block hardness, tool type, enchantments, potion effects (Haste/Mining Fatigue), and block drops to determine if breaking time is legit.
  
  
• Supports both Bukkit and ProtocolLib event flows.
  
  
• Soft block handling:
  Special logic for softer blocks and multi-platform support.
  
  
• Spam reduction:
  Alert cooldown and tolerance thresholds prevent alert flooding.
  
  
• Thread safety:
  All relevant maps and data stores are thread-safe.
  

KillAuraCheck

• Directional attack detection:
  Uses field-of-view, dot product, and yaw angle to check if the target is within legitimate attack range, and not behind or outside player’s view.
  
  
• No alerts for close-proximity (legit) attacks.
  
  
• Supports both ProtocolLib and event-based flows.
  

ReachCheck

• Checks only legitimate attack events:
  Verifies that the attack is of type ENTITY_ATTACK and that the reach distance exceeds the configured threshold.
  
  
• Cooldown per player to prevent warning spam.
  
  
• Never triggers in Creative/Spectator or for bypass players.
  

JesusCheck

• Reliable fluid-walking detection:
  Triggers only if the player is genuinely walking over a fluid block (not inside it or on the edge), and only if not gliding, flying, or affected by Levitation.
  
  
• Cleans up state as needed to prevent memory leaks and false alerts.
  
  
• All checks and alerts are performed in an async-safe manner.
  

ClickPatternCheck

• Variance-based detection:
  Looks for suspiciously consistent click intervals (low variance) and high CPS before flagging.
  
  
• Auto-resets state on inactivity or if the player is mining, to avoid accidental alerts.
  
  
• CoolDown configurable per player.
  

Summary

• Much fewer false positives for all checks.
  
  
• Better user experience: inventory is fully usable, fewer unnecessary warnings, and player actions are not interrupted.
  
  
• Increased accuracy and configurability.
  
  
• Optimized performance and stability.
  
  
• Cleaner, more maintainable code.
  

⚠️ Important Notice:
This plugin has a soft dependency on ProtocolLib.
If ProtocolLib is installed, several checks (e.g., Reach, KillAura, AutoClicker, etc.) will work with greater accuracy and advanced packet analysis.
However, the plugin remains fully functional even without ProtocolLib, using standard Bukkit event listeners as a fallback.

Changelog
General / Infrastructure

• Soft ProtocolLib Integration:
  All relevant checks can use ProtocolLib for precise packet-level detection. If ProtocolLib is missing, Bukkit events are used instead.
  
  
• Thread Safety & Async Refactoring:
  Time-consuming and database-related actions run asynchronously to prevent lag; all Bukkit API calls are scheduled on the main thread.
  

ReachCheck

• Standalone Reach Check:
  The reach check was separated from KillAura and is now a dedicated class.
  
  
• ProtocolLib Support:
  Intercepts USE_ENTITY packets for precise reach detection and validation.
  
  
• Cooldown System:
  Per-player cooldowns prevent alert spamming.
  
  
• Message Variable Consistency:
  Alerts, logs, and action bar messages now use unified variables.
  
  
• Bukkit Fallback:
  If ProtocolLib isn’t present, falls back to Bukkit’s EntityDamageByEntityEvent.
  
  
• Permission & GameMode Bypass:
  Added to avoid false positives and unwanted alerts.
  

KillAuraCheck

• Reach Detection Removed:
  All logic related to reach distance moved to the new ReachCheck.
  
  
• Packet-based Orientation Checks:
  Now focuses only on orientation, dot product, angle, and yaw difference checks for legit aim detection.
  
  
• Cooldown System:
  Alert spam protection implemented.
  
  
• Optimized Async Handling:
  All heavy processing moved async, with alerts and player actions on the main thread.
  
  
• Unified Message System:
  All alerts and logs use standardized placeholders.
  

AutoClickerCheck

• ProtocolLib Support Improved:
  Added/Fixed packet-based detection for higher reliability with ProtocolLib.
  
  
• Bugfix:
  Fixed an issue where the check would not trigger or would produce false negatives.
  
  
• Cooldowns & Thread Safety:
  All detection logic now thread-safe and rate-limited per player.
  
  
• Clean Alert & Logging:
  Unified with other checks for format and clarity.
  

SpeedCheck

• Detection Logic Improved:
  
  • Fixed major bug where speed wasn’t being calculated correctly (false positives/negatives).
    
    
  • Now properly considers potion effects, enchantments, slippery surfaces (e.g. ice), and special jump cases.
    
• ProtocolLib Support:
  Now uses movement packet analysis where possible.
  
  
• Cooldown & Alert Refactoring:
  Cooldown, alert, and action bar systems now match other checks for consistency.
  

FastPlaceCheck

• Detection Logic Refined:
  
  • Improved detection window and false positive handling.
    
    
  • Now accurately counts block placements and checks timing.
    
• ProtocolLib Support:
  Now can use packet-level placement events.
  
  
• Async & Cooldown:
  All detection runs async where possible, cooldown per player.
  
  
• Message Consistency:
  Alerts and logs follow standard format.
  

FastBreakCheck

• Detection Logic Completely Overhauled:
  
  • Mining speed checks now factor in tool, enchantments, potion effects, and block type.
    
    
  • Avoids hardcoded lists by using Minecraft’s own checks wherever possible.
    
• Bugfix:
  Previously detected block breaking was too strict or too lax; fixed for much more accurate, real-world behaviour.
  
  
• ProtocolLib Support:
  Packet-based mining tracking now available when ProtocolLib is present.
  
  
• Async Processing:
  Expensive operations are performed async, with warnings/alerts dispatched safely.
  
  
• Cooldown & Thread Safety:
  Improved for reliability under high activity.
  

Miscellaneous / Shared

• Unified Variable & Logging System:
  All checks now use a consistent approach to variables and logging for easier staff review and debugging.
  
  
• Bypass Permission & Creative/Spectator Skip:
  All checks ignore users in creative/spectator or with admin bypass permission.
  
  
• Message Manager Usage:
  All player-facing messages and logs now use the plugin’s MessageManager for consistent prefixes, translations, and placeholder expansion.
  

Summary:

• ProtocolLib is supported for high-precision packet checks but not required.
  
  
• All major checks (Reach, KillAura, AutoClicker, Speed, FastPlace, FastBreak) have been reworked, improved, or fixed.
  
  
• Major bugs affecting AutoClicker, Speed, FastPlace, and FastBreak were resolved.
  
  
• Code is now fully async/thread safe, all alerts/logs use consistent messages, and the plugin is more stable than ever.
  

General

• All checks now use configuration-driven parameters: All thresholds, limits, and cooldowns are now read from checks.yml, making it easy to tune and manage every detection module without recompiling.
  
  
• Consistent code structure: Every listener/check now follows the same asynchronous handling, scheduling, and alert/reporting pipeline.
  
  
• Enhanced debug information: Debug lines and log messages have been added, especially to critical checks, to help pinpoint issues and understand behavior in real time.
  

Core Checks/Detection Modules
KillAura

• Dynamic bounding box calculation: The detection now calculates the exact closest point between the attacker’s eye position and the target’s hitbox, ensuring the hit distance is always accurate—even for mobs with large or nonstandard hitboxes.
  
  
• Angle and field of view logic improved: Checks now include:
  
  • Direction vector (dot product) for accurate FOV (field of view) analysis.
    
    
  • Calculated angle in degrees between the attacker’s look direction and the hit vector.
    
    
  • Yaw difference calculation for extra precision.
    
• Smart alert suppression: Hits are never flagged as suspicious if the attacker is physically “glued” to the target (very close distance). Alerts only trigger if the target is outside the attacker’s field of view (e.g., behind or far to the side), even if the hit is technically possible.
  
  
• All major parameters moved to config: Including min_look_dot, max_look_angle, max_yaw_diff, and the hard reach limit.

Reach

• Configurable reach threshold: Now fully adjustable via config.
  
  
• Shared logic with KillAura: Consistent application of reach calculation for both checks.
  
  
• Messages and warnings unified.
  

FastBreak, FastPlace, Scaffold, Speed, Fly, etc.

• Consistent async logic: All calculations are performed asynchronously, with Bukkit sync callbacks only for messaging and warnings.
  
  
• All time intervals, speed thresholds, event counts, and warning amounts are fully configurable in checks.yml.
  
  
• Logging and message variables: All alerts and logs now use placeholders/variables for better context and easier translation.
  

Messaging

• All messages and alerts fully translated to English.
  
  
• All messages and command usage/help sections now include descriptive comments for each line in the messages.yml config file. This makes the config much easier to read, edit, and maintain.
  
  
• Every alert and command message now has an English description explaining its purpose directly in the config as a comment.
  
  
• All parameter comments in checks.yml have been translated and clarified in English.
  

Command/Permission Structure

• Plugin plugin.yml file descriptions: All permission and command descriptions have been translated to English.
  
  
• Command usage strings and errors have been made clearer for staff and players.
  

Configuration

• checks.yml now features clear, commented explanations for every parameter, fully in English.
  
  
• All critical checks now include:
  
  • enabled
    
    
  • cooldown_ms
    
    
  • warning_amount
    
    
  • Specific thresholds/limits for detection, each with an English description.
    

Quality-of-Life & Code Consistency

• Improved reset and state-cleaning logic in all listeners (for example, movement/fall resets, on-ground and special block handling, etc.)
  
  
• Variable naming consistency across all listeners.
  
  
• Cleaner separation of sync and async code blocks for performance and reliability.
  

1. Refactoring & Unified Messaging

• All checks (Speed, Fly, Reach, Scaffold, NoFall, KillAura, AutoClicker, FastBreak, FastPlace, etc.) now exclusively use customizable messages from messages.yml for alerts, action bar, player warnings, and staff logs.
  
  
• Staff logs now use the generic.log-format without a prefix, ensuring full consistency for staff review and easier auditing.
  
  
• All variables in messages are passed using dedicated maps, with different details shown based on the showAlertDetails config option.
  

2. NoFallCheck

• Improved reset logic: fall is now reset on slabs, edges, and any block—not just solid ground. This eliminates false positives when the player stops on a ledge and then falls further.
  
  
• Updated the safeLandingBlocks list to include all boats and rafts (including chest-boats) available in MC 1.21.4.
  
  
• Fixed handling of fallDistance and other edge cases.
  
  
• Alert and log details are always consistent and fully customizable.
  

3. SpeedCheck

• Enhanced the reason-building logic and added detailed modifiers (speed, potions, special blocks, vanilla boosts, enchantments, jumps, downhill/uphill, ice, stairs, etc.) with clear details in messages and logs.
  
  
• All static messages and reasons are now dynamic and localized through messages.yml.
  
  
• Refined vanilla event detection: stairs, head-hitter, carpet on ice, frostwalker, downhill/uphill, jump-sprint, etc.

4. Check Consistency Across All Modules

• Fly, FastBreak, FastPlace, ClickPattern, InventoryWalk, Jesus, KillAura, Blink, Reach, Scaffold:
  
  • Refactored alert, warning, action bar, and staff log messaging.
    
    
  • All actions are now performed asynchronously where possible.
    
    
  • Custom details in logs and alerts, dynamic variables based on hack type detected.
    
    
  • Improved consistency across classes, all checks now use the new MessageManager.
    

5. XrayObfuscatorListener

• Standardized message handling: staff logs now use generic.log-format (no prefix), with custom alerts from messages.yml.
  
  
• Improved robustness and settings reload logic through ChecksConfig.
  
  
• Added Paper AntiXray detection: automatically disables the check if Paper’s native anti-xray is active.
  

6. General Optimizations

• All checks now use well-managed cooldown controls via config variables.
  
  
• Improved asynchronous management to avoid main server thread blocking.
  
  
• Improved structure of variables passed to messages/logs for maximum staff clarity.
  
  
• General refactoring for readability, modularity, and consistency across classes and checks.
  

7. Other Minor Fixes

• Improved handling of bypass permissions, edge cases (vehicle, gliding, creative, spectator, etc.).
  
  
• Fixes and debugging for multiple alerts, false positives, and thread safety.
  
  
• More robust against known exploits and edge cases in MC 1.21.x.
  

VirgolaAntiCheat Update - Full Changelog
NEW: Full Async Support

• Most core checks and utility classes are now fully asynchronous, ensuring less lag and higher performance. Heavy calculations run off the main server thread; all Bukkit API calls are safely scheduled on the main thread.
  

FastBreak Check

• Completely rewritten FastBreak logic.
  
  
• Now calculates the exact expected time to break blocks based on block hardness, tool type, enchantments (Efficiency), and potion effects (Haste, Mining Fatigue).
  
  
• Compares actual block break time with the expected value and alerts if the block is broken faster than possible.
  
  
• Handles both instant-break and "almost legit" hacks.
  
  
• Improved exclusion logic for hand-breaking and special tools (shears, swords, etc.).
  

Speed Check

• Now also considers speed increases due to movement in 2x1 spaces and on stairs, reducing false positives for legitimate advanced movement.
  

NoFall Check

• Optimized and stabilized: better ground detection and fewer false alerts.
  

AutoClicker & ClickPattern Checks

• Checks are now aware of block breaking: clicks made while breaking blocks are ignored to avoid false positives.
  
  
• Improved CPS and pattern analysis; only alerts on real suspicious clicking activity.
  

Anti-Xray Detection

• Now checks the paper-world-defaults.yml in /config for native Paper AntiXray instead of the old paper.yml location.
  

Bugfixes & Minor Improvements

• Fixed several bugs and improved overall code structure.
  
  
• Improved YAML reload handling.
  
  
• Several utility and manager classes refactored for clarity and speed.
  

If you encounter any bugs or have questions, please contact me directly or post in the plugin's SpigotMC discussion section!

VirgolaAntiCheat - Changelog Completo
NUOVO: Supporto Asincrono Completo

• La maggior parte dei check principali e delle utility ora sono completamente asincroni, con calcoli pesanti eseguiti fuori dal main thread per ridurre il lag. Tutte le chiamate Bukkit vengono gestite in modo sicuro sul thread principale.
  

FastBreak Check

• Logica completamente riscritta.
  
  
• Calcolo esatto del tempo minimo necessario per rompere ogni blocco in base a durezza, tipo di strumento, incantesimi (Efficienza), e effetti (Haste, Fatica da Miniera).
  
  
• Confronto tra tempo reale e teorico di rottura per segnalare tentativi di FastBreak.
  
  
• Gestione migliorata di hack che simulano tempi quasi-legit e di rotture istantanee.
  
  
• Esclusione ottimizzata per casi legit (es. mano, cesoie, spade...).
  

Speed Check

• Ora tiene conto dell’aumento di velocità dovuto a movimenti in spazi 2x1 e sulla salita delle scale, limitando i falsi positivi per trick di movimento avanzato.
  

NoFall Check

• Ottimizzato: migliore riconoscimento del terreno e meno falsi positivi.
  

Check AutoClicker & ClickPattern

• Ora ignorano i click fatti mentre si rompono blocchi, evitando falsi positivi durante il mining rapido.
  
  
• Analisi CPS e pattern riviste; alert solo su attività realmente sospetta.
  

Anti-Xray Detection

• Il controllo per l’AntiXray nativo Paper ora legge il file /config/paper-world-defaults.yml invece del vecchio paper.yml.
  

Bugfix & Migliorie Varie

• Risolti diversi bug e migliorata la struttura generale del codice.
  
  
• Migliorata la gestione del reload dei file YAML.
  
  
• Alcune classi utility e manager sono state rifattorizzate per maggior chiarezza ed efficienza.
  

Per qualsiasi bug o domanda, contattami direttamente o scrivi nella sezione Discussioni di SpigotMC!

Changelog - VirgolaAntiCheat Update
[NEW & IMPROVED FEATURES]

• KillAura detection overhaul:
  Now detects attacks not only on players but on any living entity, with improved precision even on small mobs. Enhanced checks based on player's facing angle (yaw) and hitbox position. Alerts are now triggered on the first truly suspicious hit.
  
  
• Configurable sensitivity:
  min_look_angle, cooldown_ms, and warning_amount for KillAura (and max_reach for Reach) can be customized from checks.yml.
  
  
• Reach check update:
  Works against all entities (not just players) and is now fully configurable.
  
  
• NoFall detection rewritten:
  Now handles hacks that split falls over multiple blocks, by tracking the true cumulative fall distance and only alerting on solid, non-safe landings.
  
  
• Full check configuration reload:
  /ac reload <all|config|checks|warnings|messages> now allows you to reload all plugin files or just specific ones, without requiring a server restart.
  
  
• Manual warning reset command:
  New /ac clearwarn <player> command to reset a user's warnings instantly, with tab-completion for online players.
  
  
• Persistent warning management:
  Warning data is now synchronized properly with the warnings.yml file after every reload or manual modification.
  
  
• Enhanced command system:
  Tab-completion, error messages and usage info now cover all subcommands.
  
  
• More accurate and detailed logging
  Alerts and logs now include more context about why a player was flagged.

[FIXES & TWEAKS]

• Improved detection for: AutoClicker, Blink, ClickPattern, FastPlace, Fly, Jesus, NoFall.
  
  
• Fixed false positives for Fly detection during normal jumping or sprinting.
  
  
• KillAura and Reach: fixed missed detections on animals and mobs.
  
  
• Various code optimizations and bug fixes.

Changelog - VirgolaAntiCheat Aggiornamento
[NOVITÀ E MIGLIORAMENTI]

• Controllo KillAura riscritto:
  Ora rileva attacchi su tutte le entità viventi (non solo player), con maggiore precisione anche su mob piccoli. Il controllo tiene conto dell’angolo di visuale e della posizione effettiva colpita. L’alert ora scatta già al primo colpo realmente sospetto.
  
  
• Sensibilità configurabile:
  Parametri come min_look_angle, cooldown_ms e warning_amount per KillAura (e max_reach per Reach) sono ora personalizzabili da checks.yml.
  
  
• Check Reach aggiornato:
  Funziona su tutte le entità ed è completamente configurabile.
  
  
• NoFall detection riscritta:
  Gestisce anche i cheat che frammentano la caduta, sommando l’altezza reale della caduta e segnalando solo atterraggi su blocchi solidi non “safe”.
  
  
• Ricarica completa delle configurazioni:
  Il comando /ac reload <all|config|checks|warnings|messages> consente ora di ricaricare tutti i file del plugin o solo quelli desiderati, senza riavvio del server.
  
  
• Reset warning manuale:
  Nuovo comando /ac clearwarn <giocatore> per azzerare immediatamente i warning di un utente, con completamento automatico per i player online.
  
  
• Gestione warning persistente:
  I warning ora sono sempre sincronizzati con warnings.yml dopo ogni reload o modifica manuale.
  
  
• Sistema comandi migliorato:
  Tab-completion, messaggi di errore e info uso ora coprono tutti i sottocomandi disponibili.
  
  
• Log e alert più dettagliati:
  Tutte le segnalazioni ora sono accompagnate da dettagli aggiuntivi sul motivo del flag.

[FIX E OTTIMIZZAZIONI]

• Migliorata la rilevazione di: AutoClicker, Blink, ClickPattern, FastPlace, Fly, Jesus, NoFall.
  
  
• Ridotti i falsi positivi del check Fly durante salti o corsa normale.
  
  
• KillAura e Reach: corretta la mancata rilevazione su animali e mob.
  
  
• Varie ottimizzazioni e bugfix minori.

VirgolaAntiCheat - Patch di Aggiornamento
Data: 29/07/2025
Compatibilità: PaperMC 1.21.4
Versione consigliata: Ultima build stabile

✨ Miglioramenti Confermati
FastBreak Check Migliorato

• Aggiunta una lista estesa di blocchi istantanei, ora correttamente ignorati dal controllo.
  
  
• Debug interno migliorato per mostrare:
  
  • Tipo di blocco rotto
    
    
  • Tempo trascorso tra una rottura e l’altra
    
• Parametri completamente configurabili tramite checks.yml:
  
  yaml
  FastBreak:
  enabled: true
  min_break_interval_ms: 150
  cooldown_ms: 1000
  warning_amount: 20
  

⚠️ FastPlace Check reso meno sensibile

• Migliorata la tolleranza tra piazzamenti ravvicinati per evitare falsi positivi.
  
  
• Debug dettagliato per comprendere velocità e distanza tra i blocchi.
  
  
• Configurabile da checks.yml:
  
  yaml
  FastPlace:
  enabled: true
  min_interval_ms: 80
  cooldown_ms: 1500
  warning_amount: 15
  

ChecksConfig migliorato

• Supporto completo per tipi int, long, double, String[] e Set<String> nel file checks.yml
  
  
• Accesso sicuro e reload dinamico dei parametri di configurazione.
  

VirgolaAntiCheat - Update Patch
Date: 29/07/2025
Compatibility: PaperMC 1.21.4
Recommended Version: Latest stable build

✨ Confirmed Improvements
Enhanced FastBreak Check

• Expanded list of instant break blocks (leaves, torches, flowers, carpets, etc.) now properly ignored.
  
  
• Improved internal debug showing:
  
  • Block type
    
    
  • Time between consecutive breaks
    
• Fully configurable via checks.yml:
  
  yaml
  FastBreak:
  enabled: true
  min_break_interval_ms: 150
  cooldown_ms: 1000
  warning_amount: 20
  

⚠️ FastPlace Check Less Sensitive

• Improved tolerance for rapid block placement to reduce false positives.
  
  
• Added debug showing speed and distance between blocks.
  
  
• Fully configurable from checks.yml:
  
  yaml
  FastPlace:
  enabled: true
  min_interval_ms: 80
  cooldown_ms: 1500
  warning_amount: 15
  

Improved ChecksConfig

• Full support for int, long, double, String[], and Set<String> from checks.yml
  
  
• Safe access and live reloading of configuration parameters.
  

**Changelog – Latest Update**

- [Improved] NoFall detection: Now accurately detects all NoFall cheats, including advanced "step" bypasses that split the fall into micro-steps. Only real landings on solid blocks are considered, minimizing false positives and catching all known NoFall hacks.
- [Improved] All NoFall alerts, warnings, and logs are fully integrated into the warning and logging system: infractions are persistent and managed in sync with bans and stats.
- [Improved] ActionBar and alert messages for NoFall are now fully customizable via `messages.yml`. Alert permissions are configurable.
- [Improved] Command tab-completion: `/ac` now supports all subcommands, including `toggle`, `togglemenu`, `trust`, `untrust`, `gui`, `stats`, `reload`, and `logs`, as well as online players and available checks.
- [Improved] Handling of legitimate falls: no more false positives when landing on water, ladders, vines, vehicles, slime/honey blocks, scaffolding, or cobwebs.
- [Fix] All known bugs with fall detection and logging have been resolved.
- [Fix] Code cleaned up and optimized for better reliability and performance.

*If you are updating from an older version, please review your messages.yml for new options and reload the plugin after replacing the jar!*

⭐ **Update Highlights – Major Improvements & Fixes!** ⭐

This update brings significant improvements and bug fixes to several core checks of VirgolaAntiCheat:

• **AutoClicker**: Improved detection accuracy and reduced false positives. Now reliably flags both hardware and software auto-clickers while allowing for legitimate fast clicking.
• **Blink**: Enhanced detection of abnormal movement packets and illegal teleportation. The Blink check is now more resistant to bypasses and provides clearer staff alerts.
• **ClickPattern**: Overhauled detection algorithm for unnatural click patterns, providing faster detection and more consistent warnings, especially against advanced click macros.
• **FastPlace**: Improved timing checks and player movement analysis. FastPlace bypasses are now detected more consistently, with optimized performance and logging.
• **Fly**: Completely revamped check, with improved tolerance for lag and legitimate movement. Now more sensitive to subtle fly cheats, while minimizing false positives.
• **Jesus**: Increased reliability for water walking and liquid bypass detection. False positives when swimming or using boats have been minimized.
• **NoFall**: See detailed notes above — now detects all forms of NoFall, including the latest step-based cheats.

**Other general improvements:**
- All alerts, warnings, and logs are now fully integrated with the persistent logging and warning system.
- All related messages are customizable via `messages.yml`.
- The `/ac` command tab completion has been improved for better staff efficiency.
- Multiple bug fixes and performance optimizations for more reliable operation.

**We recommend updating your configuration files and reviewing your messages.yml for the new options!**

Thank you for supporting VirgolaAntiCheat – Your feedback drives us forward!



**Changelog – Ultimo aggiornamento**

- [Migliorato] Rilevamento NoFall: ora il controllo rileva ogni tipo di cheat NoFall, inclusi i bypass “a step” che spezzano la caduta. Il plugin considera solo gli atterraggi reali su blocchi solidi, riducendo i falsi positivi e intercettando tutti i NoFall conosciuti.
- [Migliorato] Alert, warning e log NoFall sono ora completamente integrati con il sistema di warning e log persistenti. Le infrazioni vengono gestite in modo uniforme e compatibile con ban e statistiche.
- [Migliorato] Messaggi di alert e ActionBar per NoFall completamente personalizzabili tramite `messages.yml`. Permessi di notifica configurabili.
- [Migliorato] Tab-completion dei comandi `/ac`: ora supporta tutti i sottocomandi, compresi `toggle`, `togglemenu`, `trust`, `untrust`, `gui`, `stats`, `reload`, e `logs`, oltre ai player online e ai check disponibili.
- [Migliorato] Gestione delle cadute legittime: nessun falso positivo su acqua, scale, liane, veicoli, blocchi slime/honey, scaffolding o ragnatele.
- [Fix] Risolti tutti i bug noti relativi al rilevamento della caduta e ai log.
- [Fix] Codice ottimizzato per prestazioni e affidabilità maggiori.

*Se aggiorni da una versione precedente, ricontrolla il tuo messages.yml per le nuove opzioni e ricarica il plugin dopo aver sostituito il jar!*

⭐ **Novità dell’aggiornamento – Migliorie e fix importanti!** ⭐

Questo aggiornamento introduce numerosi miglioramenti e correzioni ad alcuni dei check principali di VirgolaAntiCheat:

• **AutoClicker**: Maggiore precisione nella rilevazione e riduzione dei falsi positivi. Il sistema ora segnala con affidabilità sia gli autoclicker hardware che software, permettendo comunque i click rapidi legittimi.
• **Blink**: Rilevamento potenziato di pacchetti di movimento anomali e teletrasporti illegali. Il check Blink è ora più resistente ai bypass e fornisce alert più chiari allo staff.
• **ClickPattern**: Algoritmo di rilevamento completamente rivisto per identificare pattern di click innaturali, con una segnalazione più rapida e coerente, anche contro macro evoluti.
• **FastPlace**: Migliorati i controlli sui tempi e l’analisi dei movimenti. I bypass FastPlace vengono ora rilevati in modo più costante, con migliori prestazioni e logging dettagliato.
• **Fly**: Check completamente riscritto, con maggiore tolleranza al lag e ai movimenti leciti. Ora più sensibile ai cheat fly più subdoli, ma con meno falsi positivi.
• **Jesus**: Rilevamento più affidabile per camminate sull’acqua e bypass sui liquidi. I falsi positivi durante il nuoto o l’uso di barche sono stati ridotti al minimo.
• **NoFall**: Vedi note dettagliate sopra — ora il plugin rileva tutte le varianti di NoFall, inclusi gli ultimi cheat basati su step.

**Altri miglioramenti generali:**
- Alert, warning e log completamente integrati con il sistema persistente.
- Tutti i messaggi sono ora personalizzabili tramite `messages.yml`.
- Tab-completion dei comandi `/ac` migliorata per una gestione staff più efficiente.
- Numerosi bugfix e ottimizzazioni delle prestazioni per un funzionamento più affidabile.

**Consigliamo di aggiornare i file di configurazione e di rivedere il messages.yml per le nuove opzioni!**

Grazie per aver scelto VirgolaAntiCheat – il tuo feedback ci aiuta a migliorare!