[Cursor Review] Implement piercing enchantment

server/entity/projectile.go

@@ -1,6 +1,12 @@
 package entity
 
 import (
+	"iter"
+	"math"
+	"math/rand/v2"
+	"slices"
+	"time"
+
 	"github.com/df-mc/dragonfly/server/block"
 	"github.com/df-mc/dragonfly/server/block/cube"
 	"github.com/df-mc/dragonfly/server/block/cube/trace"
@@ -9,10 +15,6 @@ import (
 	"github.com/df-mc/dragonfly/server/item/potion"
 	"github.com/df-mc/dragonfly/server/world"
 	"github.com/go-gl/mathgl/mgl64"
-	"iter"
-	"math"
-	"math/rand/v2"
-	"time"
 )
 
 // ProjectileBehaviourConfig allows the configuration of projectiles. Calling
@@ -80,6 +82,10 @@ type ProjectileBehaviourConfig struct {
 	// CollisionPosition specifies the position that the projectile is stuck
 	// in. If non-empty, the entity will not move.
 	CollisionPosition cube.Pos
+	// PiercingLevel is the crossbow Piercing enchantment level. The projectile
+	// passes through PiercingLevel entities and damages PiercingLevel+1 in
+	// total. A value of 0 means no piercing.
+	PiercingLevel int
 }
 
 func (conf ProjectileBehaviourConfig) Apply(data *world.EntityData) {
@@ -109,6 +115,8 @@ type ProjectileBehaviour struct {
 
 	collisionPos cube.Pos
 	collided     bool
+
+	collidedEntities []*world.EntityHandle
 }
 
 // Owner returns the owner of the projectile.
@@ -168,8 +176,11 @@ func (lt *ProjectileBehaviour) Tick(e *Ent, tx *world.Tx) *Movement {
 
 	switch r := result.(type) {
 	case trace.EntityResult:
-		if l, ok := r.Entity().(Living); ok && lt.conf.Damage >= 0 {
-			lt.hitEntity(l, e, vel)
+		if l, ok := r.Entity().(Living); ok {
+			if lt.conf.Damage >= 0 {
+				lt.hitEntity(l, e, vel)
+			}
+			lt.collidedEntities = append(lt.collidedEntities, l.H())
 		}
 	case trace.BlockResult:
 		bpos := r.BlockPosition()
@@ -180,12 +191,15 @@ func (lt *ProjectileBehaviour) Tick(e *Ent, tx *world.Tx) *Movement {
 			lt.hitBlockSurviving(e, r, m, tx)
 			return m
 		}
+		lt.close = true
 	}
 	if lt.conf.Hit != nil {
 		lt.conf.Hit(e, tx, result)
 	}
 
-	lt.close = true
+	if len(lt.collidedEntities) > lt.conf.PiercingLevel {
+		lt.close = true
+	}
 	return m
 }
 
@@ -264,6 +278,7 @@ func (lt *ProjectileBehaviour) hitEntity(l Living, e *Ent, vel mgl64.Vec3) {
 	if lt.conf.Critical {
 		dmg += rand.Float64() * dmg / 2
 	}
+	// TODO: Piercing arrows should bypass shield blocking when shields are implemented.
 	if _, vulnerable := l.Hurt(dmg, src); vulnerable {
 		l.KnockBack(l.Position().Sub(vel), 0.45+lt.conf.KnockBackForceAddend, 0.3608+lt.conf.KnockBackHeightAddend)
 
@@ -312,7 +327,7 @@ func (lt *ProjectileBehaviour) tickMovement(e *Ent, tx *world.Tx) (*Movement, tr
 				mx, my, mz := hit.Face().Axis().Vec3().Mul(-2).Add(mgl64.Vec3{1, 1, 1}).Elem()
 
 				vel = mgl64.Vec3{x * mx, y * my, z * mz}
-			} else {
+			} else if lt.conf.PiercingLevel == 0 {
 				vel = zeroVec3
 			}
 			end = hit.Position()
@@ -322,15 +337,19 @@ func (lt *ProjectileBehaviour) tickMovement(e *Ent, tx *world.Tx) (*Movement, tr
 }
 
 // ignores returns a function to ignore entities in trace.Perform that are
-// either a spectator, not living, the entity itself or its owner in the first
-// 5 ticks.
+// either a spectator, not living, the entity itself, its owner in the first
+// 5 ticks, or an entity it already collided with.
 func (lt *ProjectileBehaviour) ignores(e *Ent) trace.EntityFilter {
 	return func(seq iter.Seq[world.Entity]) iter.Seq[world.Entity] {
 		return func(yield func(world.Entity) bool) {
 			for other := range seq {
 				g, ok := other.(interface{ GameMode() world.GameMode })
+				spectator := ok && !g.GameMode().HasCollision()
+				itself := e.H() == other.H()
 				_, living := other.(Living)
-				if (ok && !g.GameMode().HasCollision()) || e.H() == other.H() || !living || (e.data.Age < time.Second/4 && lt.conf.Owner == other.H()) {
+				owner := e.data.Age < time.Second/4 && lt.conf.Owner == other.H()
+				collidedEntity := slices.Contains(lt.collidedEntities, other.H())
+				if spectator || itself || !living || owner || collidedEntity {
 					continue
 				}
 				if !yield(other) {

server/entity/register.go

@@ -47,15 +47,17 @@ var conf = world.EntityRegistryConfig{
 	SplashPotion: func(opts world.EntitySpawnOpts, t any, owner world.Entity) *world.EntityHandle {
 		return NewSplashPotion(opts, t.(potion.Potion), owner)
 	},
-	Arrow: func(opts world.EntitySpawnOpts, damage float64, owner world.Entity, critical, disallowPickup, obtainArrowOnPickup bool, punchLevel int, tip any) *world.EntityHandle {
+	Arrow: func(opts world.EntitySpawnOpts, arrow world.ArrowSpawnConfig) *world.EntityHandle {
+		tip := arrow.Tip.(potion.Potion)
 		conf := arrowConf
-		conf.Damage, conf.Potion, conf.Owner = damage, tip.(potion.Potion), owner.H()
-		conf.KnockBackForceAddend = float64(punchLevel) * enchantment.Punch.KnockBackMultiplier()
-		conf.DisablePickup = disallowPickup
-		if obtainArrowOnPickup {
-			conf.PickupItem = item.NewStack(item.Arrow{Tip: tip.(potion.Potion)}, 1)
+		conf.Damage, conf.Potion, conf.Owner = arrow.Damage, tip, arrow.Owner.H()
+		conf.KnockBackForceAddend = float64(arrow.PunchLevel) * enchantment.Punch.KnockBackMultiplier()
+		conf.DisablePickup = arrow.DisablePickup
+		if arrow.ObtainArrowOnPickup {
+			conf.PickupItem = item.NewStack(item.Arrow{Tip: tip}, 1)
 		}
-		conf.Critical = critical
+		conf.Critical = arrow.Critical
+		conf.PiercingLevel = arrow.PiercingLevel
 		return opts.New(ArrowType, conf)
 	},
 }

server/item/bow.go

@@ -78,8 +78,19 @@ func (Bow) Release(releaser Releaser, tx *world.Tx, ctx *UseContext, duration ti
 	}
 
 	create := tx.World().EntityRegistry().Config().Arrow
-	opts := world.EntitySpawnOpts{Position: eyePosition(releaser), Velocity: releaser.Rotation().Vec3().Mul(force * 5), Rotation: releaser.Rotation().Neg()}
-	projectile := tx.AddEntity(create(opts, damage, releaser, force >= 1, false, !creative && consume, punchLevel, tip))
+	opts := world.EntitySpawnOpts{
+		Position: eyePosition(releaser),
+		Velocity: releaser.Rotation().Vec3().Mul(force * 5),
+		Rotation: releaser.Rotation().Neg(),
+	}
+	projectile := tx.AddEntity(create(opts, world.ArrowSpawnConfig{
+		Damage:              damage,
+		Owner:               releaser,
+		Critical:            force >= 1,
+		ObtainArrowOnPickup: !creative && consume,
+		PunchLevel:          punchLevel,
+		Tip:                 tip,
+	}))
 	if f, ok := projectile.(interface{ SetOnFire(duration time.Duration) }); ok {
 		f.SetOnFire(burnDuration)
 	}

server/item/crossbow.go

@@ -122,18 +122,27 @@ func (c Crossbow) ReleaseCharge(releaser Releaser, tx *world.Tx, ctx *UseContext
 	held, _ := releaser.HeldItems()
 	creative := releaser.GameMode().CreativeInventory()
 
-	multishot := false
+	pierceLevel, multishot := 0, false
 	for _, enchant := range held.Enchantments() {
 		if _, ok := enchant.Type().(interface{ MultipleProjectiles() bool }); ok {
 			multishot = true
-			break
+		}
+		if _, ok := enchant.Type().(interface{ Pierces() bool }); ok {
+			pierceLevel = enchant.Level()
 		}
 	}
 
-	c.shoot(releaser, tx, 0, !creative)
+	arrowConf := world.ArrowSpawnConfig{
+		Damage:              9,
+		Owner:               releaser,
+		ObtainArrowOnPickup: !creative,
+		PiercingLevel:       pierceLevel,
+	}
+	c.shoot(releaser, tx, 0, arrowConf)
 	if multishot {
-		c.shoot(releaser, tx, -10, false)
-		c.shoot(releaser, tx, 10, false)
+		arrowConf.ObtainArrowOnPickup = false
+		c.shoot(releaser, tx, -10, arrowConf)
+		c.shoot(releaser, tx, 10, arrowConf)
 	}
 	c.applyDamage(ctx)
 
@@ -146,7 +155,7 @@ func (c Crossbow) ReleaseCharge(releaser Releaser, tx *world.Tx, ctx *UseContext
 }
 
 // shoot fires the crossbow's loaded projectiles.
-func (c Crossbow) shoot(releaser Releaser, tx *world.Tx, offsetAngle float64, canObtainPickup bool) {
+func (c Crossbow) shoot(releaser Releaser, tx *world.Tx, offsetAngle float64, arrowConf world.ArrowSpawnConfig) {
 	rot := releaser.Rotation()
 	dirVec := cube.Rotation{rot[0] + offsetAngle, rot[1]}.Vec3()
 
@@ -160,11 +169,12 @@ func (c Crossbow) shoot(releaser Releaser, tx *world.Tx, offsetAngle float64, ca
 		tx.AddEntity(projectile)
 	} else {
 		createArrow := tx.World().EntityRegistry().Config().Arrow
+		arrowConf.Tip = c.Item.Item().(Arrow).Tip
 		arrow := createArrow(world.EntitySpawnOpts{
 			Position: torsoPosition(releaser),
 			Velocity: dirVec.Mul(5.15),
 			Rotation: rot.Neg(),
-		}, 9, releaser, false, false, canObtainPickup, 0, c.Item.Item().(Arrow).Tip)
+		}, arrowConf)
 		tx.AddEntity(arrow)
 	}
 }

server/item/enchantment/multishot.go

@@ -32,8 +32,7 @@ func (multishot) Rarity() item.EnchantmentRarity {
 
 // CompatibleWithEnchantment ...
 func (multishot) CompatibleWithEnchantment(t item.EnchantmentType) bool {
-	// TODO: Multishot is incompatible with Piercing
-	return true
+	return t != Piercing
 }
 
 // CompatibleWithItem ...

server/item/enchantment/piercing.go

@@ -0,0 +1,40 @@
+package enchantment
+
+import (
+	"github.com/df-mc/dragonfly/server/item"
+	"github.com/df-mc/dragonfly/server/world"
+)
+
+// Piercing is an enchantment that allows arrows to damage and pierce through multiple entities, including shields.
+var Piercing piercing
+
+type piercing struct{}
+
+func (p piercing) Name() string {
+	return "Piercing"
+}
+
+func (p piercing) MaxLevel() int {
+	return 4
+}
+
+func (p piercing) Cost(level int) (int, int) {
+	return 1 + (level-1)*10, 50
+}
+
+func (p piercing) Rarity() item.EnchantmentRarity {
+	return item.EnchantmentRarityCommon
+}
+
+func (p piercing) CompatibleWithEnchantment(t item.EnchantmentType) bool {
+	return t != Multishot
+}
+
+func (p piercing) CompatibleWithItem(i world.Item) bool {
+	_, ok := i.(item.Crossbow)
+	return ok
+}
+
+func (p piercing) Pierces() bool {
+	return true
+}

server/item/enchantment/register.go

@@ -37,7 +37,7 @@ func init() {
 	// TODO: (31) Loyalty.
 	// TODO: (32) Channeling.
 	item.RegisterEnchantment(33, Multishot)
-	// TODO: (34) Piercing.
+	item.RegisterEnchantment(34, Piercing)
 	item.RegisterEnchantment(35, QuickCharge)
 	item.RegisterEnchantment(36, SoulSpeed)
 	item.RegisterEnchantment(37, SwiftSneak)

server/item/stack.go

@@ -276,6 +276,21 @@ func (s Stack) WithEnchantments(enchants ...Enchantment) Stack {
 			// Enchantment is not compatible with the item.
 			continue
 		}
+		compatible := true
+		for _, otherEnchant := range s.enchantments {
+			addingType := enchant.t
+			existingType := otherEnchant.Type()
+			addingAcceptsExisting := addingType.CompatibleWithEnchantment(existingType)
+			existingAcceptsAdding := existingType.CompatibleWithEnchantment(addingType)
+			if addingType != existingType && (!addingAcceptsExisting || !existingAcceptsAdding) {
+				compatible = false
+				break
+			}
+		}
+		if !compatible {
+			// Enchantment is not compatible with another enchantment on the item.
+			continue
+		}
 		s.enchantments[enchant.t] = enchant
 	}
 	return s

server/world/entity.go

@@ -366,7 +366,7 @@ type EntityRegistryConfig struct {
 	FallingBlock       func(opts EntitySpawnOpts, bl Block) *EntityHandle
 	TNT                func(opts EntitySpawnOpts, fuse time.Duration) *EntityHandle
 	BottleOfEnchanting func(opts EntitySpawnOpts, owner Entity) *EntityHandle
-	Arrow              func(opts EntitySpawnOpts, damage float64, owner Entity, critical, disallowPickup, obtainArrowOnPickup bool, punchLevel int, tip any) *EntityHandle
+	Arrow              func(opts EntitySpawnOpts, conf ArrowSpawnConfig) *EntityHandle
 	Egg                func(opts EntitySpawnOpts, owner Entity) *EntityHandle
 	EnderPearl         func(opts EntitySpawnOpts, owner Entity) *EntityHandle
 	Firework           func(opts EntitySpawnOpts, firework Item, owner Entity, sidewaysVelocityMultiplier, upwardsAcceleration float64, attached bool) *EntityHandle
@@ -376,6 +376,28 @@ type EntityRegistryConfig struct {
 	Lightning          func(opts EntitySpawnOpts) *EntityHandle
 }
 
+// ArrowSpawnConfig holds the options used to spawn an arrow entity.
+type ArrowSpawnConfig struct {
+	// Damage specifies the base damage dealt by the arrow.
+	Damage float64
+	// Owner is the entity that fired the arrow.
+	Owner Entity
+	// Critical specifies if the arrow should deal critical damage.
+	Critical bool
+	// DisablePickup specifies if picking up the arrow should be disabled.
+	DisablePickup bool
+	// ObtainArrowOnPickup specifies if the arrow should be returned as an item when picked up.
+	ObtainArrowOnPickup bool
+	// PunchLevel specifies the level of punch knockback applied to the arrow.
+	PunchLevel int
+	// PiercingLevel is the crossbow Piercing enchantment level. The arrow passes
+	// through PiercingLevel entities and damages PiercingLevel+1 in total. A
+	// value of 0 means no piercing.
+	PiercingLevel int
+	// Tip specifies the potion tip carried by the arrow.
+	Tip any
+}
+
 // New creates an EntityRegistry using conf and the EntityTypes passed.
 func (conf EntityRegistryConfig) New(ent []EntityType) EntityRegistry {
 	m := make(map[string]EntityType, len(ent))