Implemented shields

server/entity/arrow.go

@@ -191,6 +191,11 @@ func (a *Arrow) Rotation() (float64, float64) {
 	return a.yaw, a.pitch
 }
 
+// blocker represents an entity that can block attacks with a shield.
+type blocker interface {
+	Blocking() (bool, bool)
+}
+
 // Tick ...
 func (a *Arrow) Tick(w *world.World, current int64) {
 	if a.close {
@@ -242,24 +247,30 @@ func (a *Arrow) Tick(w *world.World, current int64) {
 				v.ViewEntityAction(a, ArrowShakeAction{Duration: time.Millisecond * 350})
 			}
 		} else if res, ok := result.(trace.EntityResult); ok {
-			if living, ok := res.Entity().(Living); ok && !living.AttackImmune() {
-				living.Hurt(a.damage(pastVel), damage.SourceProjectile{Projectile: a, Owner: a.owner})
-				living.KnockBack(m.pos, 0.45, 0.3608)
-				for _, eff := range a.tip.Effects() {
-					living.AddEffect(eff)
-				}
-				if flammable, ok := living.(Flammable); ok && a.OnFireDuration() > 0 {
-					flammable.SetOnFire(time.Second * 5)
+			if l, ok := res.Entity().(Living); ok && !l.AttackImmune() {
+				a.close = true
+				if b, ok := l.(blocker); ok {
+					if ok, _ := b.Blocking(); ok {
+						a.vel, a.close = pastVel.Mul(-0.25), false
+					}
 				}
-				if a.punchLevel > 0 {
-					horizontalVel := pastVel
-					horizontalVel[1] = 0
-					if speed := horizontalVel.Len(); speed > 0 {
-						multiplier := (enchantment.Punch{}).PunchMultiplier(a.punchLevel, speed)
-						living.SetVelocity(living.Velocity().Add(mgl64.Vec3{pastVel[0] * multiplier, 0.1, pastVel[2] * multiplier}))
+				if _, vulnerable := l.Hurt(a.damage(pastVel), damage.SourceProjectile{Projectile: a, Owner: a.owner}); vulnerable {
+					l.KnockBack(m.pos, 0.45, 0.3608)
+					for _, eff := range a.tip.Effects() {
+						l.AddEffect(eff)
+					}
+					if flammable, ok := l.(Flammable); ok && a.OnFireDuration() > 0 {
+						flammable.SetOnFire(time.Second * 5)
+					}
+					if a.punchLevel > 0 {
+						horizontalVel := pastVel
+						horizontalVel[1] = 0
+						if speed := horizontalVel.Len(); speed > 0 {
+							multiplier := (enchantment.Punch{}).PunchMultiplier(a.punchLevel, speed)
+							l.SetVelocity(l.Velocity().Add(mgl64.Vec3{pastVel[0] * multiplier, 0.1, pastVel[2] * multiplier}))
+						}
 					}
 				}
-				a.close = true
 			}
 		}
 

server/item/register.go

@@ -107,6 +107,7 @@ func init() {
 	world.RegisterItem(Salmon{})
 	world.RegisterItem(Scute{})
 	world.RegisterItem(Shears{})
+	world.RegisterItem(Shield{})
 	world.RegisterItem(ShulkerShell{})
 	world.RegisterItem(Slimeball{})
 	world.RegisterItem(Snowball{})

server/item/shield.go

@@ -0,0 +1,30 @@
+package item
+
+// Shield is a tool used for protecting the player against attacks.
+type Shield struct{}
+
+// MaxCount ...
+func (Shield) MaxCount() int {
+	return 1
+}
+
+// RepairableBy ...
+func (Shield) RepairableBy(i Stack) bool {
+	if planks, ok := i.Item().(interface{ RepairsWoodTools() bool }); ok {
+		return planks.RepairsWoodTools()
+	}
+	return false
+}
+
+// DurabilityInfo ...
+func (s Shield) DurabilityInfo() DurabilityInfo {
+	return DurabilityInfo{
+		MaxDurability: 336,
+		BrokenItem:    simpleItem(Stack{}),
+	}
+}
+
+// EncodeItem ...
+func (Shield) EncodeItem() (name string, meta int16) {
+	return "minecraft:shield", 0
+}

server/player/player.go

@@ -68,8 +68,10 @@ type Player struct {
 	invisible, immobile, onGround, usingItem atomic.Bool
 	usingSince atomic.Int64
 
-	glideTicks   atomic.Int64
-	fireTicks    atomic.Int64
+	blockingDelayTicks atomic.Int64
+	glideTicks         atomic.Int64
+	fireTicks          atomic.Int64
+
 	fallDistance atomic.Float64
 
 	breathing         bool
@@ -545,9 +547,46 @@ func (p *Player) Hurt(dmg float64, source damage.Source) (float64, bool) {
 		return 0, true
 	}
 
+	w, pos := p.World(), p.Position()
 	totalDamage := p.FinalDamageFrom(dmg, source)
-	damageLeft := totalDamage
+	if ok, _ := p.Blocking(); ok && source.ReducedByArmour() {
+		affected := true
+		if src, ok := source.(damage.SourceEntityAttack); ok {
+			diff := p.Position().Sub(src.Attacker.Position())
+			diff[1] = 0
+			if diff.Dot(entity.DirectionVector(p)) >= 0.0 {
+				affected = false
+			}
+		}
+		if affected {
+			w.PlaySound(pos, sound.ShieldBlock{})
+			p.SetBlockingDelay(time.Millisecond * 250)
+
+			if src, ok := source.(damage.SourceEntityAttack); ok {
+				if l, ok := src.Attacker.(entity.Living); ok {
+					l.KnockBack(pos, 0.5, 0.4)
+				}
+				if a, ok := src.Attacker.(*Player); ok {
+					held, _ := a.HeldItems()
+					if _, ok := held.Item().(item.Axe); ok {
+						p.SetBlockingDelay(time.Second * 5)
+					}
+				}
+			}
+			if dmg >= 3.0 {
+				i := int(math.Ceil(totalDamage))
+				held, other := p.HeldItems()
+				if _, ok := held.Item().(item.Shield); ok {
+					p.SetHeldItems(p.damageItem(held, i), other)
+				} else {
+					p.SetHeldItems(held, p.damageItem(other, i))
+				}
+			}
+			return 0, false
+		}
+	}
 
+	damageLeft := totalDamage
 	if a := p.Absorption(); a > 0 {
 		if damageLeft > a {
 			damageLeft -= a
@@ -565,7 +604,7 @@ func (p *Player) Hurt(dmg float64, source damage.Source) (float64, bool) {
 
 		var damageToAttacker int
 		damageToArmour := int(math.Max(math.Floor(dmg/4), 1))
-		thornsArmour := map[int]item.Stack{}
+		thornsArmour := make(map[int]item.Stack)
 		for slot, it := range p.armour.Slots() {
 			if _, ok := it.Item().(item.Durable); ok {
 				if e, ok := it.Enchantment(enchantment.Thorns{}); ok && rand.Float64() < float64(e.Level())*0.15 {
@@ -600,7 +639,6 @@ func (p *Player) Hurt(dmg float64, source damage.Source) (float64, bool) {
 		}
 	}
 
-	w, pos := p.World(), p.Position()
 	for _, viewer := range p.viewers() {
 		viewer.ViewEntityAction(p, entity.HurtAction{})
 	}
@@ -968,8 +1006,8 @@ func (p *Player) StopSprinting() {
 	if !p.sprinting.CAS(true, false) {
 		return
 	}
-	p.SetSpeed(p.Speed() / 1.3)
 
+	p.SetSpeed(p.Speed() / 1.3)
 	p.updateState()
 }
 
@@ -1079,6 +1117,18 @@ func (p *Player) StopFlying() {
 	p.session().SendGameMode(p.GameMode())
 }
 
+// Blocking returns true if the player is currently blocking with a shield. The first boolean is true if the player was
+// holding a shield. The second boolean is true if the player was performing the necessary actions in order to block.
+func (p *Player) Blocking() (bool, bool) {
+	if p.BlockingDelay() > 0 || !p.sneaking.Load() || p.usingItem.Load() {
+		return false, false
+	}
+	held, other := p.HeldItems()
+	_, heldShield := held.Item().(item.Shield)
+	_, otherShield := other.Item().(item.Shield)
+	return heldShield || otherShield, true
+}
+
 // Jump makes the player jump if they are on ground. It exhausts the player by 0.05 food points, an additional 0.15
 // is exhausted if the player is sprint jumping.
 func (p *Player) Jump() {
@@ -1164,6 +1214,11 @@ func (p *Player) OnFireDuration() time.Duration {
 	return time.Duration(p.fireTicks.Load()) * time.Second / 20
 }
 
+// BlockingDelay ...
+func (p *Player) BlockingDelay() time.Duration {
+	return time.Duration(p.blockingDelayTicks.Load()) * time.Second / 20
+}
+
 // SetOnFire ...
 func (p *Player) SetOnFire(duration time.Duration) {
 	ticks := int64(duration.Seconds() * 20)
@@ -1174,6 +1229,15 @@ func (p *Player) SetOnFire(duration time.Duration) {
 	p.updateState()
 }
 
+// SetBlockingDelay ...
+func (p *Player) SetBlockingDelay(duration time.Duration) {
+	blocking, _ := p.Blocking()
+	p.blockingDelayTicks.Store(int64(duration.Seconds() * 20))
+	if blocking {
+		p.updateState()
+	}
+}
+
 // Extinguish ...
 func (p *Player) Extinguish() {
 	p.SetOnFire(0)
@@ -1345,11 +1409,11 @@ func (p *Player) UseItem() {
 			return
 		}
 		p.SetHeldItems(p.subtractItem(i, 1), left)
+		w.PlaySound(p.Position().Add(mgl64.Vec3{0, 1.5}), sound.Burp{})
 
 		useCtx := p.useContext()
 		useCtx.NewItem = usable.Consume(w, p)
 		p.addNewItem(useCtx)
-		w.PlaySound(p.Position().Add(mgl64.Vec3{0, 1.5}), sound.Burp{})
 	}
 }
 
@@ -1360,6 +1424,7 @@ func (p *Player) UseItem() {
 // the item started being used.
 func (p *Player) ReleaseItem() {
 	if !p.usingItem.CAS(true, false) || !p.canRelease() || !p.GameMode().AllowsInteraction() {
+		p.updateState()
 		return
 	}
 	ctx := p.useContext()
@@ -2290,6 +2355,12 @@ func (p *Player) Tick(w *world.World, current int64) {
 			p.Hurt(1, damage.SourceFireTick{})
 		}
 	}
+	if p.BlockingDelay() > 0 {
+		p.blockingDelayTicks.Sub(1)
+		if p.BlockingDelay() <= 0 {
+			p.SetBlockingDelay(0)
+		}
+	}
 
 	if current%4 == 0 && p.usingItem.Load() {
 		held, _ := p.HeldItems()
@@ -2657,6 +2728,17 @@ func (p *Player) SwingArm() {
 	if p.Dead() {
 		return
 	}
+
+	duration := time.Millisecond * 300
+	if e, ok := p.Effect(effect.Haste{}); ok {
+		duration -= time.Duration(e.Level()) * time.Millisecond * 50
+	} else if e, ok = p.Effect(effect.MiningFatigue{}); ok {
+		duration += time.Duration(e.Level()*2) * time.Millisecond * 50
+	}
+	if duration > 0 {
+		p.SetBlockingDelay(duration)
+	}
+
 	for _, v := range p.viewers() {
 		v.ViewEntityAction(p, entity.SwingArmAction{})
 	}

server/session/entity_metadata.go

@@ -23,12 +23,19 @@ func (s *Session) parseEntityMetadata(e world.Entity) entityMetadata {
 		dataKeyPotionColour:      int32(0),
 		dataKeyPotionAmbient:     byte(0),
 		dataKeyColour:            byte(0),
+		dataKeyFlags:             int64(0),
+		dataKeyFlagsExtended:     int64(0),
 	}
 
 	m.setFlag(dataKeyFlags, dataFlagAffectedByGravity)
 	m.setFlag(dataKeyFlags, dataFlagCanClimb)
 	if sn, ok := e.(sneaker); ok && sn.Sneaking() {
 		m.setFlag(dataKeyFlags, dataFlagSneaking)
+		if b, ok := e.(blocker); ok {
+			if _, ok = b.Blocking(); ok {
+				m.setFlag(dataKeyFlagsExtended, dataFlagBlocking)
+			}
+		}
 	}
 	if sp, ok := e.(sprinter); ok && sp.Sprinting() {
 		m.setFlag(dataKeyFlags, dataFlagSprinting)
@@ -142,10 +149,9 @@ func (s *Session) parseEntityMetadata(e world.Entity) entityMetadata {
 // setFlag sets a flag with a specific index in the int64 stored in the entity metadata map to the value
 // passed. It is typically used for entity metadata flags.
 func (m entityMetadata) setFlag(key uint32, index uint8) {
-	if v, ok := m[key]; !ok {
-		m[key] = int64(0) ^ (1 << uint64(index))
-	} else {
-		m[key] = v.(int64) ^ (1 << uint64(index))
+	actualIndex := index % 64
+	if v, ok := m[key]; ok {
+		m[key] = v.(int64) ^ (1 << uint64(actualIndex))
 	}
 }
 
@@ -174,6 +180,7 @@ const (
 	dataKeyAreaEffectCloudParticleID           = 63
 	dataKeyAlwaysShowNameTag                   = 81
 	dataKeyScoreTag                            = 84
+	dataKeyFlagsExtended                       = 92
 	dataKeyAreaEffectCloudDuration             = 95
 	dataKeyAreaEffectCloudSpawnTime            = 96
 	dataKeyAreaEffectCloudRadiusPerTick        = 97
@@ -189,19 +196,21 @@ const (
 	dataFlagSprinting
 	dataFlagUsingItem
 	dataFlagInvisible
-	dataFlagIgnited           = 10
-	dataFlagCritical          = 13
-	dataFlagCanShowNameTag    = 14
-	dataFlagAlwaysShowNameTag = 15
-	dataFlagNoAI              = 16
-	dataFlagCanClimb          = 19
-	dataFlagGliding           = 32
-	dataFlagBreathing         = 35
-	dataFlagLinger            = 46
-	dataFlagHasCollision      = 47
-	dataFlagAffectedByGravity = 48
-	dataFlagEnchanted         = 51
-	dataFlagSwimming          = 56
+	dataFlagIgnited            = 10
+	dataFlagCritical           = 13
+	dataFlagCanShowNameTag     = 14
+	dataFlagAlwaysShowNameTag  = 15
+	dataFlagNoAI               = 16
+	dataFlagCanClimb           = 19
+	dataFlagGliding            = 32
+	dataFlagBreathing          = 35
+	dataFlagLinger             = 46
+	dataFlagHasCollision       = 47
+	dataFlagAffectedByGravity  = 48
+	dataFlagEnchanted          = 51
+	dataFlagSwimming           = 56
+	dataFlagBlocking           = 71
+	dataFlagTransitionBlocking = 72
 )
 
 type sneaker interface {
@@ -220,6 +229,10 @@ type glider interface {
 	Gliding() bool
 }
 
+type blocker interface {
+	Blocking() (bool, bool)
+}
+
 type breather interface {
 	Breathing() bool
 	AirSupply() time.Duration

server/session/world.go

@@ -673,6 +673,8 @@ func (s *Session) playSound(pos mgl64.Vec3, t world.Sound, disableRelative bool)
 		}
 	case sound.MusicDiscEnd:
 		pk.SoundType = packet.SoundEventRecordNull
+	case sound.ShieldBlock:
+		pk.SoundType = packet.SoundEventShieldBlock
 	case sound.FireCharge:
 		s.writePacket(&packet.LevelEvent{
 			EventType: packet.LevelEventSoundBlazeFireball,

server/world/sound/item.go

@@ -70,3 +70,6 @@ type GoatHorn struct {
 // FireCharge is a sound played when a player lights a block on fire with a fire charge, or when a dispenser or a
 // blaze shoots a fireball.
 type FireCharge struct{ sound }
+
+// ShieldBlock is a sound played when a player blocks an attack using a shield.
+type ShieldBlock struct{ sound }