ServerProtection
MadeSimple

public class ViolationManager {
    private static final String PREFIX = "[BlockShield] ";
    private static final String LOG_FORMAT = "%s flagged for %s (x%d)";
    private static final long DECAY_TIME = 300000L;
    private final Map<UUID, Map<String, Integer>> violations;
    private final Map<UUID, Long> lastViolation;
    private final BanManager banManager;
    private int totalViolations;

    public ViolationManager(BanManager banManager) {
        this.violations = new ConcurrentHashMap<>();
        this.lastViolation = new ConcurrentHashMap<>();
        this.banManager = banManager;
        this.totalViolations = 0;
    }

    public int addViolation(UUID player, String checkName) {
        Map<String, Integer> playerVls = violations
            .computeIfAbsent(player, k -> new ConcurrentHashMap<>());
        int vl = playerVls.merge(checkName, 1, Integer::sum);
        lastViolation.put(player, System.currentTimeMillis());
        totalViolations++;

        String name = getPlayerName(player);
        Logger.info(String.format(LOG_FORMAT, name, checkName, vl));

        if (vl >= banManager.getThreshold(checkName)) {
            banManager.executeBan(player,
                PREFIX + "Excessive " + checkName + " violations");
        }
        return vl;
    }

    public void decay() {
        long now = System.currentTimeMillis();
        lastViolation.forEach((uuid, time) -> {
            if (now - time > DECAY_TIME) {
                violations.remove(uuid);
                lastViolation.remove(uuid);
            }
        });
    }

    public Map<String, Integer> getViolations(UUID player) {
        return violations.getOrDefault(player, Collections.emptyMap());
    }

    public void clear() {
        violations.clear();
        lastViolation.clear();
        totalViolations = 0;
    }
}

public class ViolationManager {
    private static final String U;
    private static final String q;
    private static final long O = (long)(0x493E0 ^ 0x400);
    private final Map x;
    private final Map t;
    private final xc b;
    private int H;

    static {
        int[] n = new int[]{-782341092, 0x7C3A1, --3};
        int[] n2 = new int[]{943812001, -0x2B1C, 3 ^ 3};
        int[] n3 = new int[]{0x4FA301, -129381, 5 >> 3};
        U = ja_0.J(n, n2, n3, new int[3 & 4],
            -1495741345, 0x37 & 0x5E);
        int[] n4 = new int[]{381209471, 0x91A3C, 2 ^ 3};
        int[] n5 = new int[]{-471829310, 0x3C1, --2};
        int[] n6 = new int[]{0x8B2103, -2819301, 3 >> 2};
        q = ja_0.J(n4, n5, n6, new int[5 >> 2],
            547901223, 0x23 ^ 0x71);
    }

    public ViolationManager(xc b) {
        aa_0.J(890, new Object[]{this, b});
    }

    public int J(UUID u, String s) {
        return (Integer)aa_0.J(891,
            new Object[]{this, u, s});
    }

    public void b() {
        aa_0.J(892, new Object[]{this});
    }

    public Map J(UUID u) {
        return (Map)aa_0.J(893,
            new Object[]{this, u});
    }

    public void J() {
        aa_0.J(894, new Object[]{this});
    }
}

public class ServiceLocator {
    private static ServiceLocator instance;
    private FlyCheck flyCheck;
    private SpeedCheck speedCheck;
    private TeleportCheck teleportCheck;
    private KillAuraCheck killAuraCheck;
    private ReachCheck reachCheck;
    private TimerCheck timerCheck;
    private ConfigManager configManager;
    private BanManager banManager;
    private ViolationManager violationManager;
    private DashboardClient dashboardClient;

    public static ServiceLocator getInstance() {
        if (instance == null) {
            instance = new ServiceLocator();
        }
        return instance;
    }

    public FlyCheck getFlyCheck() {
        return this.flyCheck;
    }
    public SpeedCheck getSpeedCheck() {
        return this.speedCheck;
    }
    public TeleportCheck getTeleportCheck() {
        return this.teleportCheck;
    }
    public KillAuraCheck getKillAuraCheck() {
        return this.killAuraCheck;
    }
    public ReachCheck getReachCheck() {
        return this.reachCheck;
    }
    public TimerCheck getTimerCheck() {
        return this.timerCheck;
    }
    public ConfigManager getConfigManager() {
        return this.configManager;
    }
    public BanManager getBanManager() {
        return this.banManager;
    }
    public ViolationManager getViolationManager() {
        return this.violationManager;
    }
    public DashboardClient getDashboardClient() {
        return this.dashboardClient;
    }

    public boolean initialize(BlockShieldPlugin plugin) {
        this.configManager = new ConfigManager(plugin);
        this.banManager = new BanManager(plugin);
        this.violationManager = new ViolationManager(banManager);
        this.flyCheck = new FlyCheck(configManager);
        this.speedCheck = new SpeedCheck(configManager);
        this.teleportCheck = new TeleportCheck(configManager);
        this.killAuraCheck = new KillAuraCheck(configManager);
        this.reachCheck = new ReachCheck(configManager);
        this.timerCheck = new TimerCheck(configManager);
        this.dashboardClient = new DashboardClient(configManager);
        return true;
    }

    public void shutdown() {
        this.banManager.saveAll();
        this.violationManager.clear();
        this.dashboardClient.disconnect();
    }
}

public final class hc {
    private static hc U;
    private ma q;
    private Ad O;
    private v_0 x;
    private dc t;
    private jd b;
    private Qc H;
    private NB f;
    private xc z;
    private Rb_0 L;
    private Gd I;

    public static hc J() {
        return (hc)aa_0.J(1180,
            new Object[0]);
    }

    public ma b() {
        return (ma)aa_0.J(1181,
            new Object[]{this});
    }

    public Ad J(int n) {
        return (Ad)aa_0.J(1182,
            new Object[]{this});
    }

    public v_0 J(long l) {
        return (v_0)aa_0.J(1183,
            new Object[]{this});
    }

    public dc b(int n) {
        return (dc)aa_0.J(1184,
            new Object[]{this});
    }

    public jd J(String s) {
        return (jd)aa_0.J(1185,
            new Object[]{this});
    }

    public Qc b(long l) {
        return (Qc)aa_0.J(1186,
            new Object[]{this});
    }

    public NB J(boolean z) {
        return (NB)aa_0.J(1187,
            new Object[]{this});
    }

    public xc b(String s) {
        return (xc)aa_0.J(1188,
            new Object[]{this});
    }

    public Rb_0 J(byte n) {
        return (Rb_0)aa_0.J(1189,
            new Object[]{this});
    }

    public Gd b(boolean z) {
        return (Gd)aa_0.J(1190,
            new Object[]{this});
    }

    public boolean b(BlockShieldPlugin p) {
        return (Boolean)aa_0.J(1191,
            new Object[]{this, p});
    }

    public void J(char c) {
        aa_0.J(1192,
            new Object[]{this});
    }
}

public class SpeedDetector extends AbstractCheck {
    private static final double MAX_SPEED = 8.0;
    private static final double MAX_SPRINT = 12.5;
    private static final double TOLERANCE = 0.15;
    private static final long SAMPLE_WINDOW = 500L;
    private static final String CHECK_NAME = "Speed";
    private static final String BAN_REASON = "Speed hack detected";

    private final Map<UUID, List<MoveSample>> samples;
    private final Map<UUID, Integer> violations;
    private int totalChecks;
    private boolean enabled;

    public SpeedDetector(ConfigManager config) {
        super("SpeedDetector", config);
        this.samples = new ConcurrentHashMap<>();
        this.violations = new ConcurrentHashMap<>();
        this.totalChecks = 0;
        this.enabled = config.getBoolean("speed.enabled", true);
    }

    @Override
    public CheckResult check(Player player, MoveEvent event) {
        if (!enabled) return CheckResult.PASS;
        UUID id = player.getUUID();
        Vector3d from = event.getFrom();
        Vector3d to = event.getTo();
        long now = System.currentTimeMillis();

        double dx = to.x - from.x;
        double dz = to.z - from.z;
        double horizontal = Math.sqrt(dx * dx + dz * dz);

        List<MoveSample> history = samples.computeIfAbsent(
            id, k -> new ArrayList<>());
        history.add(new MoveSample(horizontal, now));
        history.removeIf(s -> now - s.time > SAMPLE_WINDOW);
        totalChecks++;

        if (history.size() < 3) {
            return CheckResult.PASS;
        }

        double avgSpeed = history.stream()
            .mapToDouble(s -> s.speed)
            .average().orElse(0.0);

        double maxAllowed = player.isSprinting()
            ? MAX_SPRINT : MAX_SPEED;
        maxAllowed *= (1.0 + TOLERANCE);

        if (avgSpeed > maxAllowed) {
            int vl = violations.merge(id, 1, Integer::sum);
            Logger.warn(String.format(
                "%s failed %s: %.2f > %.2f (vl:%d)",
                player.getName(), CHECK_NAME,
                avgSpeed, maxAllowed, vl));
            return new CheckResult(
                CheckResult.Type.FAIL,
                String.format("%.2f > %.2f", avgSpeed, maxAllowed),
                vl);
        }
        return CheckResult.PASS;
    }

    public void reset(UUID player) {
        samples.remove(player);
        violations.remove(player);
    }

    public Map<UUID, Integer> getViolations() {
        return Collections.unmodifiableMap(violations);
    }

    public int getTotalChecks() {
        return this.totalChecks;
    }
}

public final class qB extends m_0 {
    private static final double L = 8.0;
    private static final double I = 12.5;
    private static final double k;
    private static final long A;
    private static final String Il;
    private static final String lI;

    private final Map II;
    private final Map Iu;
    private int IlI;
    private boolean lIl;

    static {
        k = Double.longBitsToDouble(0x3FC3333333L);
        A = (long)(0x1F4 ^ 0x100);
        int[] n = new int[]{-129448371, 0xAB3C1, 7 & 3};
        int[] n2 = new int[]{883401772, -37291, 5 >> 2};
        Il = ja_0.J(n, n2, new int[]{0x91},
            new int[0], -1495741345, 0x37 & 0x5E);
        int[] n3 = new int[]{749103281, 0x1BB7C0, 3 ^ 3};
        int[] n4 = new int[]{-308217546, -1227139, 2 ^ 3};
        lI = ja_0.J(n3, n4, new int[]{0x4C91A},
            new int[0], 547901223, 0x23 ^ 0x71);
    }

    public qB(NB n) {
        aa_0.J(2100, new Object[]{this, n});
    }

    public l_0 J(Player p, IB e) {
        return (l_0)aa_0.J(2101,
            new Object[]{this, p, e});
    }

    public void b(UUID u) {
        aa_0.J(2102,
            new Object[]{this, u});
    }

    public Map J(int n) {
        return (Map)aa_0.J(2103,
            new Object[]{this});
    }

    public int J() {
        return (Integer)aa_0.J(2104,
            new Object[]{this});
    }
}