Initial commit

This commit is contained in:
Scifi9902
2026-10-12 13:57:05 -03:00
commit 4bde3b176a
2576 changed files with 212659 additions and 0 deletions
+92
View File
@@ -0,0 +1,92 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>ProjectCranked</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>AsyncHitDetection</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<repositories>
<repository>
<id>jitpack.io</id>
<url>https://jitpack.io</url>
</repository>
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
<repository>
<id>funkemunky-releases</id>
<url>https://nexus.funkemunky.cc/content/repositories/releases/</url>
</repository>
</repositories>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<minimizeJar>false</minimizeJar>
<createDependencyReducedPom>false</createDependencyReducedPom>
<filters>
<filter>
<artifact>io.github.retrooper:packetevents</artifact>
<excludes>
<exclude>plugin.yml</exclude>
</excludes>
</filter>
</filters>
<relocations>
<relocation>
<pattern>io.github.retrooper.packetevents</pattern>
<shadedPattern>net.crankedpvp.hitdetection.libs.packetevents</shadedPattern>
</relocation>
</relocations>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
</build>
<dependencies>
<dependency>
<groupId>io.github.retrooper</groupId>
<artifactId>packetevents</artifactId>
<version>v1.8.4</version>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,80 @@
package net.crankedpvp.hitdetection;
import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
import io.github.retrooper.packetevents.packettype.PacketType;
import io.github.retrooper.packetevents.packetwrappers.play.in.useentity.WrappedPacketInUseEntity;
import io.github.retrooper.packetevents.packetwrappers.play.out.entitystatus.WrappedPacketOutEntityStatus;
import net.crankedpvp.hitdetection.util.KnockbackUtil;
import net.crankedpvp.hitdetection.util.KnockbackUtil_8;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PacketProcessor {
public static final String handlerName = "transactions";
public static PacketProcessor INSTANCE;
private final Map<String, Long> delay = new HashMap<>();
public final ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
private KnockbackUtil knockbackUtil;
public PacketProcessor() {
INSTANCE = this;
}
public void load() {
knockbackUtil = new KnockbackUtil_8();
}
public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
if (event.getPacketId() == PacketType.Play.Client.USE_ENTITY) {
Player player = event.getPlayer();
WrappedPacketInUseEntity useEntity = new WrappedPacketInUseEntity(event.getNMSPacket());
Entity entity = useEntity.getEntity();
WrappedPacketInUseEntity.EntityUseAction action = useEntity.getAction();
if (action == WrappedPacketInUseEntity.EntityUseAction.ATTACK
&& entity.getType() == EntityType.PLAYER) {
if (delay.containsKey(player.getName())) {
long s = ((System.currentTimeMillis() - delay.get(player.getName())) / 1000) * 20;
if (s < 5) {
event.setCancelled(true);
return;
}
}
WrappedPacketOutEntityStatus status = new WrappedPacketOutEntityStatus(entity, (byte) 2);
delay.put(player.getName(), System.currentTimeMillis());
applyKnockback(player, (Player) entity, status);
event.setCancelled(true);
}
}
}
public void damageEntity(Player player, Entity target) {
knockbackUtil.damageEntity(player, target);
}
public void applyKnockback(Player player, Player damaged, WrappedPacketOutEntityStatus status) {
executorService.execute(() -> knockbackUtil.applyKnockback(player, damaged, status));
}
public void g(Player player, double d0, double d1, double d2) {
knockbackUtil.g(player, d0, d1, d2);
}
public void injectPlayer(Player player) {
knockbackUtil.injectPlayer(player);
}
public void ejectPlayer(Player player) {
knockbackUtil.ejectPlayer(player);
}
}
@@ -0,0 +1,60 @@
package net.crankedpvp.hitdetection;
import io.github.retrooper.packetevents.PacketEvents;
import org.bukkit.event.EventHandler;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;
public class Transactions extends JavaPlugin {
public static Transactions INSTANCE;
private final PacketProcessor processor = new PacketProcessor();;
@Override
public void onLoad() {
INSTANCE = this;
/*
* PacketEvents likes to maintain compatibility with other plugins shading the same API.
* If some other API loaded before you, the create method will return it's PacketEvents instance
* to maintain compatibility, otherwise you will create the instance.
* Set the settings.
*/
PacketEvents.create(this).getSettings().checkForUpdates(false);
/*
* Access the stored instance of the PacketEvents class and load PacketEvents.
* A few settings need to be specified before loading PacketEvents
* as PacketEvents already uses a few in the load method.
* To be safe, just set them all before loading.
*/
PacketEvents.get().load();
}
@Override
public void onEnable() {
//Initiate PacketEvents
PacketEvents.get().init(this);
processor.load();
}
@Override
public void onDisable() {
//Terminate PacketEvents
processor.executorService.shutdown();
PacketEvents.get().terminate();
}
@EventHandler
public void onJoin(PlayerJoinEvent event) {
processor.injectPlayer(event.getPlayer());
}
@EventHandler
public void onQuit(PlayerQuitEvent event) {
processor.ejectPlayer(event.getPlayer());
}
}
@@ -0,0 +1,18 @@
package net.crankedpvp.hitdetection.util;
import io.github.retrooper.packetevents.packetwrappers.play.out.entitystatus.WrappedPacketOutEntityStatus;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
public interface KnockbackUtil {
void damageEntity(Player player, Entity target);
void applyKnockback(Player player, Player target, WrappedPacketOutEntityStatus status);
void g(Player player, double deltaMotX, double deltaMotY, double deltaMotZ);
void injectPlayer(Player player);
void ejectPlayer(Player player);
}
@@ -0,0 +1,143 @@
package net.crankedpvp.hitdetection.util;
import io.github.retrooper.packetevents.PacketEvents;
import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
import io.github.retrooper.packetevents.packetwrappers.play.out.entitystatus.WrappedPacketOutEntityStatus;
import io.github.retrooper.packetevents.utils.nms.NMSUtils;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;
import net.crankedpvp.hitdetection.PacketProcessor;
import net.minecraft.server.v1_8_R3.*;
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.v1_8_R3.entity.*;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityCombustByEntityEvent;
import org.bukkit.event.player.PlayerVelocityEvent;
import java.util.List;
public class KnockbackUtil_8 implements KnockbackUtil {
@Override
public void damageEntity(Player player, Entity target) {
EntityPlayer ep = ((CraftPlayer)player).getHandle();
net.minecraft.server.v1_8_R3.Entity nmsEntity = ((CraftEntity)target).getHandle();
boolean disablePlayerCrits = false;
float f = (float) ep.getAttributeInstance(GenericAttributes.ATTACK_DAMAGE).getValue();
byte b0 = 0;
float f1;
if (nmsEntity instanceof EntityLiving) {
f1 = EnchantmentManager.a(ep.bA(), ((EntityLiving) nmsEntity).getMonsterType());
} else {
f1 = EnchantmentManager.a(ep.bA(), EnumMonsterType.UNDEFINED);
}
int i = b0 + EnchantmentManager.a(ep);
if (ep.isSprinting()) {
++i;
}
if (f > 0.0F || f1 > 0.0F) {
boolean flag = !disablePlayerCrits && ep.fallDistance > 0.0F && !ep.onGround && !ep.k_() && !ep.V() && !ep.hasEffect(MobEffectList.BLINDNESS) && ep.vehicle == null && nmsEntity instanceof EntityLiving; // PaperSpigot
if (flag && f > 0.0F) {
f *= 1.5F;
}
f += f1;
int j = EnchantmentManager.getFireAspectEnchantmentLevel(ep);
if (nmsEntity instanceof EntityLiving && j > 0 && !nmsEntity.isBurning()) {
// CraftBukkit start - Call a combust event when somebody hits with a fire enchanted item
EntityCombustByEntityEvent combustEvent = new EntityCombustByEntityEvent(ep.getBukkitEntity(), nmsEntity.getBukkitEntity(), 1);
org.bukkit.Bukkit.getPluginManager().callEvent(combustEvent);
if (!combustEvent.isCancelled()) {
nmsEntity.setOnFire(combustEvent.getDuration());
}
// CraftBukkit end
}
nmsEntity.damageEntity(DamageSource.playerAttack(ep), f);
}
}
@Override
public void applyKnockback(Player player, Player target, WrappedPacketOutEntityStatus status) {
for (Player p : Bukkit.getServer().getOnlinePlayers()) {
CraftPlayer cp = (CraftPlayer) p;
EntityPlayer ep = ((CraftPlayer) target).getHandle();
EntityPlayer epa = ((CraftPlayer) player).getHandle();
damageEntity(player, target);
double victimMotX = ep.motX;
double victimMotY = ep.motY;
double victimMotZ = ep.motZ;
ep.velocityChanged = true;
g(player, -MathHelper.sin(epa.yaw * 3.1415927F / 180.0F) * 1 * 0.5F * 0.95D * 1, 0.1D * 0.7,
MathHelper.cos(epa.yaw * 3.1415927F / 180.0F) * 1 * 0.5F * 0.95D * 1);
PlayerVelocityEvent event = new PlayerVelocityEvent(ep.getBukkitEntity(), ep.getBukkitEntity().getVelocity());
Bukkit.getPluginManager().callEvent(event);
if (!event.isCancelled()) {
ep.getBukkitEntity().setVelocity(event.getVelocity());
}
ep.velocityChanged = false;
ep.motX = victimMotX;
ep.motY = victimMotY;
ep.motZ = victimMotZ;
PacketEvents.get().getPlayerUtils().sendPacket(p,
status);
}
}
@Override
public void g(Player player, double deltaMotX, double deltaMotY, double deltaMotZ) {
EntityPlayer ep = ((CraftPlayer)player).getHandle();
ep.motX += deltaMotX;
ep.motY += deltaMotY;
ep.motZ += deltaMotZ;
ep.ai = true;
}
@Override
public void injectPlayer(Player player) {
Channel channel = (Channel) NMSUtils.getChannel(player);
channel.pipeline().addAfter("decoder", PacketProcessor.handlerName, new MessageToMessageDecoder() {
public boolean processIncomingPacket(Channel channel, Object packet) {
PacketPlayReceiveEvent event = new PacketPlayReceiveEvent(player, channel, new NMSPacket(packet));
PacketProcessor.INSTANCE.onPacketPlayReceive(event);
return event.isCancelled();
}
@Override
protected void decode(ChannelHandlerContext ctx, Object packet, List list) throws Exception {
list.add(packet);
if (!processIncomingPacket(ctx.channel(), packet)) {
list.remove(packet);
ctx.flush();
}
}
});
}
@Override
public void ejectPlayer(Player player) {
Channel channel = (Channel) NMSUtils.getChannel(player);
if (channel.pipeline().get(PacketProcessor.handlerName) != null) {
channel.pipeline().remove(PacketProcessor.handlerName);
}
}
}
@@ -0,0 +1,6 @@
name: HitDetectionPlugin
author: "frash23"
version: ${git.total.commit.count}.0
description: "§fCommit ID: §a${git.commit.id.abbrev}"
website: https://crankedpvp.net/
main: net.crankedpvp.hitdetection.Transactions