Implement vanilla shield blocking

Author: HashimTheArab

server/block/explosion.go

@@ -30,6 +30,10 @@ type ExplosionConfig struct {
 	// the item drop chance is 1/Size. If negative, no items will be dropped by
 	// the explosion. If set to 1 or higher, all items are dropped.
 	ItemDropChance float64
+	// UnblockableByShield specifies if the explosion damage should not be blockable by shields.
+	UnblockableByShield bool
+	// Source is the entity that caused the explosion, if known.
+	Source world.Entity
 
 	// Sound is the sound to play when the explosion is created. If set to nil, this will default to the sound of a
 	// regular explosion.

server/block/tnt.go

@@ -19,30 +19,30 @@ type TNT struct {
 // ProjectileHit ...
 func (t TNT) ProjectileHit(pos cube.Pos, tx *world.Tx, e world.Entity, _ cube.Face) {
 	if f, ok := e.(flammableEntity); ok && f.OnFireDuration() > 0 {
-		t.Ignite(pos, tx, nil)
+		spawnTnt(pos, tx, time.Second*4, tntIgnitionSourceHandle(e))
 	}
 }
 
 // Activate ...
 func (t TNT) Activate(pos cube.Pos, _ cube.Face, tx *world.Tx, u item.User, ctx *item.UseContext) bool {
 	held, _ := u.HeldItems()
 	if _, ok := held.Enchantment(enchantment.FireAspect); ok {
-		t.Ignite(pos, tx, nil)
+		t.Ignite(pos, tx, u)
 		ctx.DamageItem(1)
 		return true
 	}
 	return false
 }
 
 // Ignite ...
-func (t TNT) Ignite(pos cube.Pos, tx *world.Tx, _ world.Entity) bool {
-	spawnTnt(pos, tx, time.Second*4)
+func (t TNT) Ignite(pos cube.Pos, tx *world.Tx, source world.Entity) bool {
+	spawnTnt(pos, tx, time.Second*4, entityHandle(source))
 	return true
 }
 
 // Explode ...
-func (t TNT) Explode(_ mgl64.Vec3, pos cube.Pos, tx *world.Tx, _ ExplosionConfig) {
-	spawnTnt(pos, tx, time.Second/2+time.Duration(rand.IntN(int(time.Second+time.Second/2))))
+func (t TNT) Explode(_ mgl64.Vec3, pos cube.Pos, tx *world.Tx, c ExplosionConfig) {
+	spawnTnt(pos, tx, time.Second/2+time.Duration(rand.IntN(int(time.Second+time.Second/2))), tntExplosionSourceHandle(c))
 }
 
 // BreakInfo ...
@@ -66,9 +66,43 @@ func (t TNT) EncodeBlock() (name string, properties map[string]interface{}) {
 }
 
 // spawnTnt creates a new TNT entity at the given position with the given fuse duration.
-func spawnTnt(pos cube.Pos, tx *world.Tx, fuse time.Duration) {
+type ownerEntity interface {
+	ProjectileOwner() *world.EntityHandle
+}
+
+func tntIgnitionSourceHandle(source world.Entity) *world.EntityHandle {
+	if source == nil {
+		return nil
+	}
+	if o, ok := source.(ownerEntity); ok {
+		if owner := o.ProjectileOwner(); owner != nil {
+			return owner
+		}
+	}
+	return source.H()
+}
+
+func tntExplosionSourceHandle(c ExplosionConfig) *world.EntityHandle {
+	return entityHandle(c.Source)
+}
+
+func entityHandle(e world.Entity) *world.EntityHandle {
+	if e == nil {
+		return nil
+	}
+	return e.H()
+}
+
+func spawnTnt(pos cube.Pos, tx *world.Tx, fuse time.Duration, source *world.EntityHandle) {
 	tx.PlaySound(pos.Vec3Centre(), sound.TNT{})
 	tx.SetBlock(pos, nil, nil)
 	opts := world.EntitySpawnOpts{Position: pos.Vec3Centre()}
-	tx.AddEntity(tx.World().EntityRegistry().Config().TNT(opts, fuse))
+	conf := tx.World().EntityRegistry().Config()
+	if source != nil && conf.TNTWithSource != nil {
+		if e, ok := source.Entity(tx); ok {
+			tx.AddEntity(conf.TNTWithSource(opts, fuse, e))
+			return
+		}
+	}
+	tx.AddEntity(conf.TNT(opts, fuse))
 }

server/block/tnt_test.go

@@ -0,0 +1,61 @@
+package block
+
+import (
+	"testing"
+
+	"github.com/df-mc/dragonfly/server/block/cube"
+	"github.com/df-mc/dragonfly/server/world"
+	"github.com/go-gl/mathgl/mgl64"
+)
+
+type tntSourceEntity struct {
+	h     *world.EntityHandle
+	owner *world.EntityHandle
+}
+
+func (e tntSourceEntity) Close() error           { return nil }
+func (e tntSourceEntity) H() *world.EntityHandle { return e.h }
+func (e tntSourceEntity) Position() mgl64.Vec3   { return mgl64.Vec3{} }
+func (e tntSourceEntity) Rotation() cube.Rotation {
+	return cube.Rotation{}
+}
+func (e tntSourceEntity) ProjectileOwner() *world.EntityHandle { return e.owner }
+
+type tntTestEntityType struct{}
+
+func (tntTestEntityType) Open(*world.Tx, *world.EntityHandle, *world.EntityData) world.Entity {
+	return nil
+}
+func (tntTestEntityType) EncodeEntity() string                        { return "dragonfly:test_entity" }
+func (tntTestEntityType) BBox(world.Entity) cube.BBox                 { return cube.Box(0, 0, 0, 0, 0, 0) }
+func (tntTestEntityType) DecodeNBT(map[string]any, *world.EntityData) {}
+func (tntTestEntityType) EncodeNBT(*world.EntityData) map[string]any  { return nil }
+func (tntTestEntityType) Apply(data *world.EntityData)                {}
+func newTNTTestHandle() *world.EntityHandle {
+	return world.EntitySpawnOpts{}.New(tntTestEntityType{}, tntTestEntityType{})
+}
+
+func TestTNTIgnitionSourcePrefersProjectileOwner(t *testing.T) {
+	owner := newTNTTestHandle()
+	projectile := tntSourceEntity{h: newTNTTestHandle(), owner: owner}
+
+	if got := tntIgnitionSourceHandle(projectile); got != owner {
+		t.Fatalf("expected TNT ignition source to use projectile owner handle %v, got %v", owner, got)
+	}
+}
+
+func TestTNTIgnitionSourceFallsBackToIgnitingEntity(t *testing.T) {
+	projectile := tntSourceEntity{h: newTNTTestHandle()}
+
+	if got := tntIgnitionSourceHandle(projectile); got != projectile.H() {
+		t.Fatalf("expected TNT ignition source to fall back to igniting entity handle %v, got %v", projectile.H(), got)
+	}
+}
+
+func TestTNTExplosionSourceUsesExplosionConfigSource(t *testing.T) {
+	source := tntSourceEntity{h: newTNTTestHandle()}
+
+	if got := tntExplosionSourceHandle(ExplosionConfig{Source: source}); got != source.H() {
+		t.Fatalf("expected chained TNT source to use explosion config source handle %v, got %v", source.H(), got)
+	}
+}

server/entity/damage.go

@@ -4,6 +4,7 @@ import (
 	"github.com/df-mc/dragonfly/server/item"
 	"github.com/df-mc/dragonfly/server/item/enchantment"
 	"github.com/df-mc/dragonfly/server/world"
+	"github.com/go-gl/mathgl/mgl64"
 )
 
 type (
@@ -42,10 +43,21 @@ type (
 		// Projectile and Owner are the world.Entity that dealt the damage and
 		// the one that fired the projectile respectively.
 		Projectile, Owner world.Entity
+		// OnShieldBlock is called if the projectile damage is blocked by a shield.
+		OnShieldBlock func()
 	}
 
 	// ExplosionDamageSource is used for damage caused by an explosion.
-	ExplosionDamageSource struct{}
+	ExplosionDamageSource struct {
+		// Origin is the position from which the explosion damage originated.
+		Origin mgl64.Vec3
+		// HasOrigin is true if Origin is a meaningful explosion source position.
+		HasOrigin bool
+		// BlockableByShield is true if the explosion damage may be blocked by a shield.
+		BlockableByShield bool
+		// Source is the entity that caused the explosion, if known.
+		Source world.Entity
+	}
 )
 
 func (FallDamageSource) ReducedByArmour() bool     { return false }

server/entity/ent.go

@@ -40,6 +40,14 @@ func (e *Ent) Behaviour() Behaviour {
 	return e.data.Data.(Behaviour)
 }
 
+// ProjectileOwner returns the entity that owns this Ent, if its Behaviour tracks one.
+func (e *Ent) ProjectileOwner() *world.EntityHandle {
+	if owner, ok := e.Behaviour().(interface{ Owner() *world.EntityHandle }); ok {
+		return owner.Owner()
+	}
+	return nil
+}
+
 // Explode propagates the explosion behaviour of the underlying Behaviour.
 func (e *Ent) Explode(src mgl64.Vec3, impact float64, conf block.ExplosionConfig) {
 	if expl, ok := e.Behaviour().(interface {

server/entity/projectile.go

@@ -166,10 +166,13 @@ func (lt *ProjectileBehaviour) Tick(e *Ent, tx *world.Tx) *Movement {
 		tx.PlaySound(result.Position(), lt.conf.Sound)
 	}
 
+	deflected := false
 	switch r := result.(type) {
 	case trace.EntityResult:
 		if l, ok := r.Entity().(Living); ok && lt.conf.Damage >= 0 {
-			lt.hitEntity(l, e, vel)
+			if lt.hitEntity(l, e, vel) {
+				deflected = true
+			}
 		}
 	case trace.BlockResult:
 		bpos := r.BlockPosition()
@@ -184,6 +187,13 @@ func (lt *ProjectileBehaviour) Tick(e *Ent, tx *world.Tx) *Movement {
 	if lt.conf.Hit != nil {
 		lt.conf.Hit(e, tx, result)
 	}
+	if deflected {
+		m.pos = e.Position()
+		m.vel = e.Velocity()
+		m.dpos = m.pos.Sub(result.Position())
+		m.dvel = m.vel.Sub(vel)
+		return m
+	}
 
 	lt.close = true
 	return m
@@ -257,14 +267,21 @@ func (lt *ProjectileBehaviour) hitBlockSurviving(e *Ent, r trace.BlockResult, m
 // hitEntity is called when a projectile hits a Living. It deals damage to the
 // entity and knocks it back. Additionally, it applies any potion effects and
 // fire if applicable.
-func (lt *ProjectileBehaviour) hitEntity(l Living, e *Ent, vel mgl64.Vec3) {
-	owner, _ := lt.conf.Owner.Entity(e.tx)
-	src := ProjectileDamageSource{Projectile: e, Owner: owner}
+func (lt *ProjectileBehaviour) hitEntity(l Living, e *Ent, vel mgl64.Vec3) bool {
+	var owner world.Entity
+	if lt.conf.Owner != nil {
+		owner, _ = lt.conf.Owner.Entity(e.tx)
+	}
+	blocked := false
+	src := ProjectileDamageSource{Projectile: e, Owner: owner, OnShieldBlock: func() { blocked = true }}
 	dmg := math.Ceil(lt.conf.Damage * vel.Len())
 	if lt.conf.Critical {
 		dmg += rand.Float64() * dmg / 2
 	}
-	if _, vulnerable := l.Hurt(dmg, src); vulnerable {
+	if _, vulnerable := l.Hurt(dmg, src); blocked {
+		lt.deflect(e, vel)
+		return true
+	} else if vulnerable {
 		l.KnockBack(l.Position().Sub(vel), 0.45+lt.conf.KnockBackForceAddend, 0.3608+lt.conf.KnockBackHeightAddend)
 
 		for _, eff := range lt.conf.Potion.Effects() {
@@ -278,6 +295,16 @@ func (lt *ProjectileBehaviour) hitEntity(l Living, e *Ent, vel mgl64.Vec3) {
 			flammable.SetOnFire(time.Second * 5)
 		}
 	}
+	return false
+}
+
+func (lt *ProjectileBehaviour) deflect(e *Ent, vel mgl64.Vec3) {
+	if vel.Len() == 0 {
+		return
+	}
+	reflected := vel.Mul(-1)
+	e.SetVelocity(reflected)
+	e.data.Pos = e.Position().Add(reflected.Normalize().Mul(0.05))
 }
 
 // tickMovement ticks the movement of a projectile. It updates the position and

server/entity/projectile_test.go

@@ -0,0 +1,74 @@
+package entity
+
+import (
+	"testing"
+
+	"github.com/df-mc/dragonfly/server/block/cube"
+	"github.com/df-mc/dragonfly/server/entity/effect"
+	"github.com/df-mc/dragonfly/server/world"
+	"github.com/go-gl/mathgl/mgl64"
+)
+
+type projectileShieldTarget struct {
+	pos        mgl64.Vec3
+	blocked    bool
+	vulnerable bool
+}
+
+func (t *projectileShieldTarget) Close() error                           { return nil }
+func (t *projectileShieldTarget) H() *world.EntityHandle                 { return nil }
+func (t *projectileShieldTarget) Position() mgl64.Vec3                   { return t.pos }
+func (t *projectileShieldTarget) Rotation() cube.Rotation                { return cube.Rotation{} }
+func (t *projectileShieldTarget) Health() float64                        { return 20 }
+func (t *projectileShieldTarget) MaxHealth() float64                     { return 20 }
+func (t *projectileShieldTarget) SetMaxHealth(float64)                   {}
+func (t *projectileShieldTarget) Dead() bool                             { return false }
+func (t *projectileShieldTarget) Heal(float64, world.HealingSource)      {}
+func (t *projectileShieldTarget) KnockBack(mgl64.Vec3, float64, float64) {}
+func (t *projectileShieldTarget) Velocity() mgl64.Vec3                   { return mgl64.Vec3{} }
+func (t *projectileShieldTarget) SetVelocity(mgl64.Vec3)                 {}
+func (t *projectileShieldTarget) AddEffect(effect.Effect)                {}
+func (t *projectileShieldTarget) RemoveEffect(effect.Type)               {}
+func (t *projectileShieldTarget) Effects() []effect.Effect               { return nil }
+func (t *projectileShieldTarget) Speed() float64                         { return 0 }
+func (t *projectileShieldTarget) SetSpeed(float64)                       {}
+
+func (t *projectileShieldTarget) Hurt(_ float64, src world.DamageSource) (float64, bool) {
+	if s, ok := src.(ProjectileDamageSource); ok && t.blocked && s.OnShieldBlock != nil {
+		s.OnShieldBlock()
+	}
+	return 0, t.vulnerable
+}
+
+func TestProjectileDeflectsAfterShieldBlock(t *testing.T) {
+	pos := mgl64.Vec3{0, 0, 1}
+	projectile := &Ent{data: &world.EntityData{Pos: pos}}
+	behaviour := &ProjectileBehaviour{conf: ProjectileBehaviourConfig{Damage: 2}}
+	velocity := mgl64.Vec3{0, 0, -1}
+
+	blocked := behaviour.hitEntity(&projectileShieldTarget{blocked: true}, projectile, velocity)
+	if !blocked {
+		t.Fatal("expected shield-blocked projectile hit to be handled as a deflection")
+	}
+	if got, want := projectile.Velocity(), velocity.Mul(-1); got != want {
+		t.Fatalf("expected deflected projectile velocity %v, got %v", want, got)
+	}
+	if !projectile.Position().Sub(pos).Normalize().ApproxEqual(projectile.Velocity().Normalize()) {
+		t.Fatalf("expected projectile to move away from blocker after deflection, position changed from %v to %v with velocity %v", pos, projectile.Position(), projectile.Velocity())
+	}
+}
+
+func TestProjectileDeflectsZeroDamageShieldBlock(t *testing.T) {
+	pos := mgl64.Vec3{0, 0, 1}
+	projectile := &Ent{data: &world.EntityData{Pos: pos}}
+	behaviour := &ProjectileBehaviour{conf: ProjectileBehaviourConfig{Damage: 0}}
+	velocity := mgl64.Vec3{0, 0, -1}
+
+	blocked := behaviour.hitEntity(&projectileShieldTarget{blocked: true}, projectile, velocity)
+	if !blocked {
+		t.Fatal("expected zero damage shield-blocked projectile hit to be handled as a deflection")
+	}
+	if got, want := projectile.Velocity(), velocity.Mul(-1); got != want {
+		t.Fatalf("expected deflected projectile velocity %v, got %v", want, got)
+	}
+}

server/entity/register.go

@@ -29,6 +29,7 @@ var DefaultRegistry = conf.New([]world.EntityType{
 
 var conf = world.EntityRegistryConfig{
 	TNT:                NewTNT,
+	TNTWithSource:      NewTNTWithSource,
 	Egg:                NewEgg,
 	Snowball:           NewSnowball,
 	BottleOfEnchanting: NewBottleOfEnchanting,