Anticheat, watched2

  • Welcome to skUnity!

    Welcome to skUnity! This is a forum where members of the Skript community can communicate and interact. Skript Resource Creators can post their Resources for all to see and use.

    If you haven't done so already, feel free to join our official Discord server to expand your level of interaction with the comminuty!

    Now, what are you waiting for? Join the community now!

F

funpvp

Member
Oct 7, 2023
47
1
8
23
so i made this
Code: 
package me.willgames_.watchedac2;

import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.events.PacketAdapter;
import com.comphenix.protocol.events.PacketContainer;
import com.comphenix.protocol.events.PacketEvent;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.HashMap;
import java.util.Map;

public class MOVECHECK implements Listener {
private final Plugin plugin;
private final LocationCache locationCache;
private final CooldownMap cooldownMap;
private final Map<Player, Integer> packetCountMap;
private Location gofrom;

public MOVECHECK(Plugin plugin) {
this.plugin = plugin;
this.locationCache = new LocationCache();
this.cooldownMap = new CooldownMap();
this.packetCountMap = new HashMap<>();

Bukkit.getPluginManager().registerEvents(new Listener() {
@EventHandler
            public void onPlayerMove(PlayerMoveEvent event) {
                Player player = event.getPlayer();
                Location from = event.getFrom();
                Location to = event.getTo();

 if (!isFlying(player)) {
                    checkMove(player);
                }
            }
        }, plugin);

ProtocolLibrary.getProtocolManager().addPacketListener(new PacketAdapter(plugin, PacketType.Play.Client.FLYING) {
@Override
            public void onPacketReceiving(PacketEvent event) {
if (event.getPacketType() == PacketType.Play.Client.FLYING) {
                    PacketContainer packet = event.getPacket();
                    Player player = event.getPlayer();

 boolean isFlying = isFlying(player);
 boolean isMoving = isPlayerMoving(player);
 boolean isOffGround = isOnGround(player);
 boolean isBlockBelowAir = isBlockBelowAir(player.getLocation());

 if (isFlying && isMoving && !isOffGround && isBlockBelowAir) {
flagPlayer(player, "FLY");
                    }
                }
            }
        });
    }

public void startChecking() {
 new BukkitRunnable() {
@Override
            public void run() {
for (Player player : Bukkit.getOnlinePlayers()) {
                    checkMove(player);
                }
            }
}.runTaskTimer(plugin, 0L, 1L);
    }

public void stopChecking() {
    }

@EventHandler
    public void onPlayerMove(PlayerMoveEvent event) {
    }

private void checkMove(Player player) {
 if (isFlying(player)) {
flagPlayer(player, "FLY");
 return;
        }

 if (isOnGround(player)) {
 return;
        }

 if (isPlayerMoving(player)) {
flagPlayer(player, "MOVE");
 return;
        }

 if (isVerticalFly(player)) {
flagPlayer(player, "VERTICALFLY");
            setBackPlayer(player);
 return;
        }

 if (isNoFall(player)) {
flagPlayer(player, "NOFALL");
            setBackPlayer(player);
 return;
        }

 if (isSpeeding(player)) {
flagPlayer(player, "SPEED");
            setBackPlayer(player);
 return;
        }

 if (isBadPackets(player)) {
flagPlayer(player, "BADPACKETS");
        }

 if (isSameSpeed(player)) {
flagPlayer(player, "SAMESPEED");
            setBackPlayer(player);
 return;
        }

 if (isConsistentSpeed(player)) {
flagPlayer(player, "CONSISTENTSPEED");
            setBackPlayer(player);
 return;
        }

 if (isForwardDescending(player)) {
flagPlayer(player, "FORWARDDESCENDING");
            setBackPlayer(player);
 return;
        }

 if (isUpwardFastMovement(player)) {
flagPlayer(player, "UPWARDFASTMOVEMENT");
            setBackPlayer(player);
        }
    }

private boolean isFlying(Player player) {
return player != null && (player.getGameMode() == GameMode.CREATIVE || player.getAllowFlight() || player.isFlying());
    }

private boolean isOnGround(Player player) {
        Location playerLocation = player.getLocation();
Location blockLocation = new Location(playerLocation.getWorld(), playerLocation.getX(), playerLocation.getY() - 1, playerLocation.getZ());
 return !blockLocation.getBlock().getType().isSolid();
    }

private boolean isPlayerMoving(Player player) {
Location from = locationCache.getLastValidLocation(player);
        Location to = player.getLocation();
 return from.getX() != to.getX() || from.getY() != to.getY() || from.getZ() != to.getZ();
    }

private boolean isVerticalFly(Player player) {
        Location playerLocation = player.getLocation().clone();
int blockCount = 0;

for (int i = 0; i < 5; i++) {
playerLocation.subtract(0, 1, 0);
            Block block = playerLocation.getBlock();

if (block.getType() == Material.AIR) {
                blockCount++;
} else {
 break;
            }
        }

return blockCount >= 4;
    }

private boolean isNoFall(Player player) {
        Location from = player.getLocation();
Location to = player.getLocation().subtract(0, 1, 0);

 double fallDistance = from.getY() - to.getY();
 double damageTaken = player.getFallDistance();

return fallDistance > 3.0 && damageTaken == 0;
    }

private boolean isSpeeding(Player player) {
Location from = locationCache.getLastValidLocation(player);
        Location to = player.getLocation();

 double distanceTraveled = from.distance(to);

return distanceTraveled > 0.55;
    }

private boolean isBadPackets(Player player) {
int threshold = 63;

int currentPackets = packetCountMap.getOrDefault(player, 0) + 1;
 packetCountMap.put(player, currentPackets);

 if (currentPackets > threshold) {
packetCountMap.put(player, 0);
 return true;
        }

 return false;
    }

private boolean isSameSpeed(Player player) {
 if (!isOnGround(player) && isPlayerMoving(player)) {
Location from = locationCache.getLastValidLocation(player);
            Location to = player.getLocation();
 double speed = calculateSpeed(from, to);

double gofromSpeed = calculateSpeed(gofrom, from);
 double gotoSpeed = calculateSpeed(from, to);

return Math.round(speed * 100.0) / 100.0 == Math.round(gofromSpeed * 100.0) / 100.0 &&
Math.round(speed * 100.0) / 100.0 == Math.round(gotoSpeed * 100.0) / 100.0;
        }

 return false;
    }

private boolean isConsistentSpeed(Player player) {
int consecutiveOffGroundCount = 0;

for (int i = 0; i < 3; i++) {
 if (!isOnGround(player) && isPlayerMoving(player) && isSameSpeed(player)) {
                consecutiveOffGroundCount++;
            }
        }

return consecutiveOffGroundCount >= 3;
    }

private boolean isForwardDescending(Player player) {
Location from = locationCache.getLastValidLocation(player);
        Location to = player.getLocation();

 if (to.getY() >= from.getY()) {
 return false;
        }

 double distanceTraveled = from.distance(to);
 double verticalDistance = from.getY() - to.getY();

return distanceTraveled > 0.29 && verticalDistance < 0.01;
    }

private boolean isUpwardFastMovement(Player player) {
Location from = locationCache.getLastValidLocation(player);
        Location to = player.getLocation();

 if (to.getY() <= from.getY()) {
 return false;
        }

 double distanceTraveled = from.distance(to);
 double verticalDistance = to.getY() - from.getY();

return distanceTraveled > 0.29 && verticalDistance > 0.29;
    }

private boolean isBlockBelowAir(Location location) {
Location playerLocation = location.subtract(0, 1.25, 0);
        Block blockBelow = playerLocation.getBlock();

return blockBelow.getType() == Material.AIR;
    }

private void flagPlayer(Player player, String checkType) {
String flagMessage = ChatColor.BLUE + "Watched " + ChatColor.GRAY + "> " +
ChatColor.BLUE + player.getName() + ChatColor.GRAY +
" failed " + ChatColor.BLUE + checkType + " " + ChatColor.GRAY + "[VL]";
        player.sendMessage(flagMessage);
Bukkit.getConsoleSender().sendMessage(flagMessage);

for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
if (onlinePlayer.hasPermission("watched.alerts")) {
                onlinePlayer.sendMessage(flagMessage);
            }
        }

cooldownMap.put(player, checkType, 60);
    }

private void setBackPlayer(Player player) {
Location lastValidLocation = locationCache.getLastValidLocation(player);
if (lastValidLocation != null) {
            player.teleport(lastValidLocation);
        }
    }

private double calculateSpeed(Location from, Location to) {
 return from.distance(to);
    }
}
on my server the console gives me a lot of null errors for playermoveevent etc
 
Last edited by a moderator:
also now its package me.willgames_.watchedac2;


import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.events.PacketAdapter;
import com.comphenix.protocol.events.PacketContainer;
import com.comphenix.protocol.events.PacketEvent;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.HashMap;
import java.util.Map;

public class MOVECHECK implements Listener {
private final Plugin plugin;
private final LocationCache locationCache;
private final CooldownMap cooldownMap;
private final Map<Player, Integer> packetCountMap;
private final Map<Player, Double> fallDistanceMap;
private final Map<Player, Long> lastPacketTimeMap;

public MOVECHECK(Plugin plugin) {
this.plugin = plugin;
this.locationCache = new LocationCache();
this.cooldownMap = new CooldownMap();
this.packetCountMap = new HashMap<>();
this.fallDistanceMap = new HashMap<>();
this.lastPacketTimeMap = new HashMap<>();

Bukkit.getPluginManager().registerEvents(this, plugin);

ProtocolLibrary.getProtocolManager().addPacketListener(new PacketAdapter(plugin, PacketType.Play.Client.FLYING) {
@Override
public void onPacketReceiving(PacketEvent event) {
if (event.getPacketType() == PacketType.Play.Client.FLYING) {
PacketContainer packet = event.getPacket();
Player player = event.getPlayer();

boolean isFlying = isFlying(player);
boolean isOffGround = isOnGround(player);
boolean isBlockBelowAir = isBlockBelowAir(player.getLocation());

if (isFlying && !isOffGround && isBlockBelowAir) {
flagPlayer(player, "FLY");
}
}
}
});
}

public void startChecking() {
new BukkitRunnable() {
@Override
public void run() {
for (Player player : Bukkit.getOnlinePlayers()) {
checkMove(player);
}
}
}.runTaskTimer(plugin, 0L, 1L);
}

public void stopChecking() {
}

@EventHandler
public void onPlayerMove(PlayerMoveEvent event) {
Player player = event.getPlayer();
Location from = event.getFrom();
Location to = event.getTo();

if (!isFlying(player)) {
checkMove(player);
}
}

private void checkMove(Player player) {
if (isFlying(player)) {
flagPlayer(player, "FLY");
return;
}

if (isOnGround(player)) {
return;
}

if (isVerticalFly(player)) {
flagPlayer(player, "VERTICALFLY");
setBackPlayer(player);
return;
}

if (isNoFall(player)) {
flagPlayer(player, "NOFALL");
setBackPlayer(player);
return;
}

if (isSpeeding(player)) {
flagPlayer(player, "SPEED");
setBackPlayer(player);
return;
}

if (isBadPackets(player)) {
flagPlayer(player, "BADPACKETS");
}

if (isSameSpeed(player)) {
flagPlayer(player, "SAMESPEED");
setBackPlayer(player);
return;
}

if (isConsistentSpeed(player)) {
flagPlayer(player, "CONSISTENTSPEED");
setBackPlayer(player);
return;
}

if (isForwardDescending(player)) {
flagPlayer(player, "FORWARDDESCENDING");
setBackPlayer(player);
return;
}

if (isUpwardFastMovement(player)) {
flagPlayer(player, "UPWARDFASTMOVEMENT");
setBackPlayer(player);
}
}

private boolean isFlying(Player player) {
return player != null && (player.getGameMode() == GameMode.CREATIVE || player.getAllowFlight() || player.isFlying());
}

private boolean isOnGround(Player player) {
Location playerLocation = player.getLocation();
Location blockLocation = new Location(playerLocation.getWorld(), playerLocation.getX(), playerLocation.getY() - 1, playerLocation.getZ());
return !blockLocation.getBlock().getType().isSolid();
}

private boolean isVerticalFly(Player player) {
Location playerLocation = player.getLocation().clone();
int blockCount = 0;

for (int i = 0; i < 5; i++) {
playerLocation.subtract(0, 1, 0);
Block block = playerLocation.getBlock();

if (block.getType() == Material.AIR) {
blockCount++;
} else {
break;
}
}

return blockCount >= 5;
}

private boolean isNoFall(Player player) {
double currentFallDistance = player.getFallDistance();
double lastFallDistance = fallDistanceMap.getOrDefault(player, 0.0);

boolean noFall = currentFallDistance < 3.1 && lastFallDistance - currentFallDistance > 3.1;

if (noFall) {
fallDistanceMap.put(player, currentFallDistance);
}

return noFall;
}

private boolean isSpeeding(Player player) {
double walkSpeed = player.getWalkSpeed();
double sprintSpeed = 0.5;

return walkSpeed > sprintSpeed;
}

private boolean isBadPackets(Player player) {
long currentTime = System.currentTimeMillis();
long lastPacketTime = lastPacketTimeMap.getOrDefault(player, 0L);

if (currentTime - lastPacketTime < 3000) {
int packetCount = packetCountMap.getOrDefault(player, 0);
packetCountMap.put(player, packetCount + 1);

if (packetCount > 63) {
packetCountMap.put(player, 0);

flagPlayer(player, "BADPACKETS");
return true;
}
} else {
packetCountMap.put(player, 0);
}

lastPacketTimeMap.put(player, currentTime);

return false;
}

private boolean isSameSpeed(Player player) {
double walkSpeed = player.getWalkSpeed();
int packetCount = packetCountMap.getOrDefault(player, 0);

return walkSpeed == 0.2 && packetCount > 5;
}

private boolean isConsistentSpeed(Player player) {
double walkSpeed = player.getWalkSpeed();
int packetCount = packetCountMap.getOrDefault(player, 0);

return walkSpeed > 0.21 && walkSpeed < 0.25 && packetCount > 5;
}

private boolean isForwardDescending(Player player) {
Location from = locationCache.getLastValidLocation(player);
Location to = player.getLocation();

double deltaX = to.getX() - from.getX();
double deltaZ = to.getZ() - from.getZ();

return deltaX == 0 && deltaZ == 0 && from.getY() > to.getY();
}

private boolean isUpwardFastMovement(Player player) {
Location from = locationCache.getLastValidLocation(player);
Location to = player.getLocation();

double deltaY = to.getY() - from.getY();

return deltaY > 0.3;
}

private void setBackPlayer(Player player) {
Location lastValidLocation = locationCache.getLastValidLocation(player);
player.teleport(lastValidLocation);
}

private boolean isBlockBelowAir(Location location) {
Location blockLocation = new Location(location.getWorld(), location.getX(), location.getY() - 1, location.getZ());
return blockLocation.getBlock().getType() == Material.AIR;
}

private void flagPlayer(Player player, String checkType) {
String flagMessage = ChatColor.BLUE + "Watched " + ChatColor.GRAY + "> " +
ChatColor.BLUE + player.getName() + ChatColor.GRAY +
" failed " + ChatColor.BLUE + checkType + " " + ChatColor.GRAY + "[" + ChatColor.BLUE + "VL" + ChatColor.GRAY + "]";
Bukkit.getConsoleSender().sendMessage(flagMessage);

for (Player onlinePlayer : Bukkit.getOnlinePlayers()) {
if (onlinePlayer.hasPermission("watched.alerts")) {
onlinePlayer.sendMessage(flagMessage);
}
}
}
}
 
You must log in or register to reply here.
Top Bottom
Back