Add EntityKnockbackByEntityEvent (#1162)

This event is called when an entity receives knockback by another entity. The knockback can be modified in the event. If the event is cancelled the entity is not knocked back.

Spigot-API-Patches/0116-Add-EntityKnockbackByEntityEvent.patch

@@ -0,0 +1,82 @@
+From ec1d10299d09e368cbafa5917ea3f34d11ad6ef5 Mon Sep 17 00:00:00 2001
+From: Brokkonaut <hannos17@gmx.de>
+Date: Mon, 18 Jun 2018 15:40:39 +0200
+Subject: [PATCH] Add EntityKnockbackByEntityEvent
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EntityKnockbackByEntityEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EntityKnockbackByEntityEvent.java
+new file mode 100644
+index 00000000..99f7ef70
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/event/entity/EntityKnockbackByEntityEvent.java
+@@ -0,0 +1,67 @@
++package com.destroystokyo.paper.event.entity;
++
++import org.bukkit.entity.Entity;
++import org.bukkit.entity.LivingEntity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.entity.EntityEvent;
++import org.bukkit.util.Vector;
++
++/**
++ * Fired when an Entity is knocked back by the hit of another Entity. The acceleration
++ * vector can be modified. If this event is cancelled, the entity is not knocked back.
++ *
++ */
++public class EntityKnockbackByEntityEvent extends EntityEvent implements Cancellable {
++    private static final HandlerList handlers = new HandlerList();
++
++    private final Entity hitBy;
++    private final float knockbackStrength;
++    private final Vector acceleration;
++    private boolean cancelled = false;
++
++    public EntityKnockbackByEntityEvent(LivingEntity entity, Entity hitBy, float knockbackStrength, Vector acceleration) {
++        super(entity);
++        this.hitBy = hitBy;
++        this.knockbackStrength = knockbackStrength;
++        this.acceleration = acceleration;
++    }
++
++    public HandlerList getHandlers() {
++        return handlers;
++    }
++
++    public static HandlerList getHandlerList() {
++        return handlers;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        cancelled = cancel;
++    }
++
++    @Override
++    public LivingEntity getEntity() {
++        return (LivingEntity) super.getEntity();
++    }
++
++    /**
++     * Returns the original knockback strength.
++     */
++    public float getKnockbackStrength() {
++        return knockbackStrength;
++    }
++
++    public Entity getHitBy() {
++        return hitBy;
++    }
++
++    public Vector getAcceleration() {
++        return acceleration;
++    }
++}
+-- 
+2.16.1.windows.1
+

Spigot-Server-Patches/0313-Implement-EntityKnockbackByEntityEvent.patch

@@ -0,0 +1,46 @@
+From 733f83fe10c98a49b22aeb10cb14e882c30d1a17 Mon Sep 17 00:00:00 2001
+From: Brokkonaut <hannos17@gmx.de>
+Date: Mon, 18 Jun 2018 15:46:23 +0200
+Subject: [PATCH] Implement EntityKnockbackByEntityEvent
+
+This event is called when an entity receives knockback by another entity.
+
+diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java
+index 65bc19b17..156bf8ee0 100644
+--- a/src/main/java/net/minecraft/server/EntityLiving.java
++++ b/src/main/java/net/minecraft/server/EntityLiving.java
+@@ -1160,6 +1160,12 @@ public abstract class EntityLiving extends Entity {
+             this.impulse = true;
+             float f1 = MathHelper.sqrt(d0 * d0 + d1 * d1);
+ 
++            // Paper start - preserve old velocity
++            double oldMotX = this.motX;
++            double oldMotY = this.motY;
++            double oldMotZ = this.motZ;
++            // Paper end
++
+             this.motX /= 2.0D;
+             this.motZ /= 2.0D;
+             this.motX -= d0 / (double) f1 * (double) f;
+@@ -1172,6 +1178,18 @@ public abstract class EntityLiving extends Entity {
+                 }
+             }
+ 
++            // Paper start - call EntityKnockbackByEntityEvent
++            org.bukkit.util.Vector delta = new org.bukkit.util.Vector(this.motX - oldMotX, this.motY - oldMotY, this.motZ - oldMotZ);
++            // Restore old velocity to be able to access it in the event
++            this.motX = oldMotX;
++            this.motY = oldMotY;
++            this.motZ = oldMotZ;
++            if (entity == null || new com.destroystokyo.paper.event.entity.EntityKnockbackByEntityEvent((LivingEntity) getBukkitEntity(), entity.getBukkitEntity(), f, delta).callEvent()) {
++                this.motX += delta.getX();
++                this.motY += delta.getY();
++                this.motZ += delta.getZ();
++            }
++            // Paper end
+         }
+     }
+ 
+-- 
+2.16.1.windows.1
+