Implemented beds

server/block/bed.go

@@ -0,0 +1,237 @@
+package block
+
+import (
+	"github.com/df-mc/dragonfly/server/block/cube"
+	"github.com/df-mc/dragonfly/server/block/model"
+	"github.com/df-mc/dragonfly/server/internal/nbtconv"
+	"github.com/df-mc/dragonfly/server/item"
+	"github.com/df-mc/dragonfly/server/world"
+	"github.com/go-gl/mathgl/mgl64"
+	"github.com/sandertv/gophertunnel/minecraft/text"
+)
+
+// Bed is a block, allowing players to sleep to set their spawns and skip the night.
+type Bed struct {
+	transparent
+
+	// Colour is the colour of the bed.
+	Colour item.Colour
+	// Facing is the direction that the bed is facing.
+	Facing cube.Direction
+	// Head is true if the bed is the head side.
+	Head bool
+	// User is the user that is using the bed.
+	User item.User
+}
+
+// MaxCount always returns 1.
+func (Bed) MaxCount() int {
+	return 1
+}
+
+// Model ...
+func (Bed) Model() world.BlockModel {
+	return model.Bed{}
+}
+
+// BreakInfo ...
+func (b Bed) BreakInfo() BreakInfo {
+	return newBreakInfo(0.2, alwaysHarvestable, nothingEffective, oneOf(b)).withBreakHandler(func(pos cube.Pos, w *world.World, _ item.User) {
+		headSide, _, ok := b.head(pos, w)
+		if !ok {
+			return
+		}
+		if s, ok := headSide.User.(world.Sleeper); ok {
+			s.Wake()
+		}
+	})
+}
+
+// CanDisplace ...
+func (Bed) CanDisplace(b world.Liquid) bool {
+	_, water := b.(Water)
+	return water
+}
+
+// SideClosed ...
+func (Bed) SideClosed(cube.Pos, cube.Pos, *world.World) bool {
+	return false
+}
+
+// UseOnBlock ...
+func (b Bed) UseOnBlock(pos cube.Pos, face cube.Face, _ mgl64.Vec3, w *world.World, user item.User, ctx *item.UseContext) (used bool) {
+	if pos, _, used = firstReplaceable(w, pos, face, b); !used {
+		return
+	}
+	if _, ok := w.Block(pos.Side(cube.FaceDown)).Model().(model.Solid); !ok {
+		return
+	}
+
+	b.Facing = user.Facing()
+
+	side, sidePos := b, pos.Side(b.Facing.Face())
+	side.Head = true
+
+	if !replaceableWith(w, sidePos, side) {
+		return
+	}
+	if _, ok := w.Block(sidePos.Side(cube.FaceDown)).Model().(model.Solid); !ok {
+		return
+	}
+
+	ctx.IgnoreBBox = true
+	place(w, sidePos, side, user, ctx)
+	place(w, pos, b, user, ctx)
+	return placed(ctx)
+}
+
+// Activate ...
+func (b Bed) Activate(pos cube.Pos, _ cube.Face, w *world.World, u item.User, _ *item.UseContext) bool {
+	s, ok := u.(world.Sleeper)
+	if !ok {
+		return false
+	}
+
+	if w.Dimension() != world.Overworld {
+		w.SetBlock(pos, nil, nil)
+		ExplosionConfig{
+			Size:      5,
+			SpawnFire: true,
+		}.Explode(w, pos.Vec3Centre())
+		return true
+	}
+
+	_, sidePos, ok := b.side(pos, w)
+	if !ok {
+		return false
+	}
+
+	userPos := s.Position()
+	if sidePos.Vec3Middle().Sub(userPos).Len() > 4 && pos.Vec3Middle().Sub(userPos).Len() > 4 {
+		s.Messaget(text.Colourf("<grey>%s</grey>", "%tile.bed.tooFar"))
+		return true
+	}
+
+	headSide, headPos, ok := b.head(pos, w)
+	if !ok {
+		return false
+	}
+	if _, ok = w.Liquid(headPos); ok {
+		return false
+	}
+
+	w.SetPlayerSpawn(s.UUID(), headPos)
+
+	time := w.Time() % world.TimeFull
+	if (time < world.TimeNight || time >= world.TimeSunrise) && !w.ThunderingAt(pos) {
+		s.Messaget(text.Colourf("<grey>%s</grey>", "%tile.bed.respawnSet"))
+		s.Messaget(text.Colourf("<grey>%s</grey>", "%tile.bed.noSleep"))
+		return true
+	}
+	if headSide.User != nil {
+		s.Messaget(text.Colourf("<grey>%s</grey>", "%tile.bed.respawnSet"))
+		s.Messaget(text.Colourf("<grey>%s</grey>", "%tile.bed.occupied"))
+		return true
+	}
+
+	s.Sleep(headPos)
+	return true
+}
+
+// EntityLand ...
+func (b Bed) EntityLand(_ cube.Pos, _ *world.World, e world.Entity) {
+	if s, ok := e.(sneakingEntity); ok && s.Sneaking() {
+		// If the entity is sneaking, the fall distance and velocity stay the same.
+		return
+	}
+	if f, ok := e.(fallDistanceEntity); ok {
+		f.SetFallDistance(f.FallDistance() * 0.5)
+	}
+	if v, ok := e.(velocityEntity); ok {
+		vel := v.Velocity()
+		vel[1] = vel[1] * -3 / 4
+		v.SetVelocity(vel)
+	}
+}
+
+// sneakingEntity represents an entity that can sneak.
+type sneakingEntity interface {
+	// Sneaking returns true if the entity is currently sneaking.
+	Sneaking() bool
+}
+
+// velocityEntity represents an entity that can maintain a velocity.
+type velocityEntity interface {
+	// Velocity returns the current velocity of the entity.
+	Velocity() mgl64.Vec3
+	// SetVelocity sets the velocity of the entity.
+	SetVelocity(mgl64.Vec3)
+}
+
+// NeighbourUpdateTick ...
+func (b Bed) NeighbourUpdateTick(pos, _ cube.Pos, w *world.World) {
+	if _, _, ok := b.side(pos, w); !ok {
+		w.SetBlock(pos, nil, nil)
+	}
+}
+
+// EncodeItem ...
+func (b Bed) EncodeItem() (name string, meta int16) {
+	return "minecraft:bed", int16(b.Colour.Uint8())
+}
+
+// EncodeBlock ...
+func (b Bed) EncodeBlock() (name string, properties map[string]interface{}) {
+	return "minecraft:bed", map[string]interface{}{
+		"facing_bit":   int32(horizontalDirection(b.Facing)),
+		"occupied_bit": boolByte(b.User != nil),
+		"head_bit":     boolByte(b.Head),
+	}
+}
+
+// EncodeNBT ...
+func (b Bed) EncodeNBT() map[string]interface{} {
+	return map[string]interface{}{
+		"id":    "Bed",
+		"color": b.Colour.Uint8(),
+	}
+}
+
+// DecodeNBT ...
+func (b Bed) DecodeNBT(data map[string]interface{}) interface{} {
+	b.Colour = item.Colours()[nbtconv.Map[uint8](data, "color")]
+	return b
+}
+
+// head returns the head side of the bed. If neither side is a head side, the third return value is false.
+func (b Bed) head(pos cube.Pos, w *world.World) (Bed, cube.Pos, bool) {
+	headSide, headPos, ok := b.side(pos, w)
+	if !ok {
+		return Bed{}, cube.Pos{}, false
+	}
+	if b.Head {
+		headSide, headPos = b, pos
+	}
+	return headSide, headPos, true
+}
+
+// side returns the other side of the bed. If the other side is not a bed, the third return value is false.
+func (b Bed) side(pos cube.Pos, w *world.World) (Bed, cube.Pos, bool) {
+	face := b.Facing.Face()
+	if b.Head {
+		face = face.Opposite()
+	}
+
+	sidePos := pos.Side(face)
+	o, ok := w.Block(sidePos).(Bed)
+	return o, sidePos, ok
+}
+
+// allBeds returns all possible beds.
+func allBeds() (beds []world.Block) {
+	for _, d := range cube.Directions() {
+		beds = append(beds, Bed{Facing: d})
+		beds = append(beds, Bed{Facing: d, Head: true})
+	}
+	return
+}

server/block/break_info.go

@@ -1,6 +1,7 @@
 package block
 
 import (
+	"github.com/df-mc/dragonfly/server/block/cube"
 	"github.com/df-mc/dragonfly/server/item"
 	"github.com/df-mc/dragonfly/server/item/enchantment"
 	"github.com/df-mc/dragonfly/server/world"
@@ -83,6 +84,8 @@ type BreakInfo struct {
 	Effective func(t item.Tool) bool
 	// Drops is a function called to get the drops of the block if it is broken using the item passed.
 	Drops func(t item.Tool, enchantments []item.Enchantment) []item.Stack
+	// BreakHandler is called after the block has broken.
+	BreakHandler func(pos cube.Pos, w *world.World, u item.User)
 	// XPDrops is the range of XP a block can drop when broken.
 	XPDrops XPDropRange
 	// BlastResistance is the blast resistance of the block, which influences the block's ability to withstand an
@@ -114,6 +117,12 @@ func (b BreakInfo) withBlastResistance(res float64) BreakInfo {
 	return b
 }
 
+// withBreakHandler sets the BreakHandler field of the BreakInfo struct to the passed value.
+func (b BreakInfo) withBreakHandler(handler func(pos cube.Pos, w *world.World, u item.User)) BreakInfo {
+	b.BreakHandler = handler
+	return b
+}
+
 // XPDropRange holds the min & max XP drop amounts of blocks.
 type XPDropRange [2]int
 

server/block/farmland.go

@@ -81,6 +81,8 @@ func (f Farmland) EntityLand(pos cube.Pos, w *world.World, e world.Entity, dista
 type fallDistanceEntity interface {
 	// ResetFallDistance resets the entities fall distance.
 	ResetFallDistance()
+	// SetFallDistance sets the entities fall distance.
+	SetFallDistance(float64)
 	// FallDistance returns the entities fall distance.
 	FallDistance() float64
 }

server/block/model/bed.go

@@ -0,0 +1,18 @@
+package model
+
+import (
+	"github.com/df-mc/dragonfly/server/block/cube"
+	"github.com/df-mc/dragonfly/server/world"
+)
+
+// Bed is a model used for beds. This model works for both parts of the bed.
+type Bed struct{}
+
+func (b Bed) BBox(cube.Pos, *world.World) []cube.BBox {
+	return []cube.BBox{cube.Box(0, 0, 0, 1, 0.5625, 1)}
+}
+
+// FaceSolid ...
+func (Bed) FaceSolid(cube.Pos, cube.Face, *world.World) bool {
+	return false
+}

server/block/register.go

@@ -108,6 +108,7 @@ func init() {
 	registerAll(allAnvils())
 	registerAll(allBarrels())
 	registerAll(allBasalt())
+	registerAll(allBeds())
 	registerAll(allBeetroot())
 	registerAll(allBlastFurnaces())
 	registerAll(allBoneBlock())
@@ -342,6 +343,7 @@ func init() {
 		world.RegisterItem(Anvil{Type: t})
 	}
 	for _, c := range item.Colours() {
+		world.RegisterItem(Bed{Colour: c})
 		world.RegisterItem(Carpet{Colour: c})
 		world.RegisterItem(ConcretePowder{Colour: c})
 		world.RegisterItem(Concrete{Colour: c})

server/player/handler.go

@@ -110,6 +110,9 @@ type Handler interface {
 	// HandleSignEdit handles the player editing a sign. It is called for every keystroke while editing a sign and
 	// has both the old text passed and the text after the edit. This typically only has a change of one character.
 	HandleSignEdit(ctx *event.Context, oldText, newText string)
+	// HandleSleepReminder handles the player broadcasting a sleeping reminder. It is called in vanilla to remind other
+	// players to sleep in order to advance the day.
+	HandleSleepReminder(ctx *event.Context)
 	// HandleItemDamage handles the event wherein the item either held by the player or as armour takes
 	// damage through usage.
 	// The type of the item may be checked to determine whether it was armour or a tool used. The damage to
@@ -157,6 +160,7 @@ func (NopHandler) HandleBlockBreak(*event.Context, cube.Pos, *[]item.Stack)
 func (NopHandler) HandleBlockPlace(*event.Context, cube.Pos, world.Block)                     {}
 func (NopHandler) HandleBlockPick(*event.Context, cube.Pos, world.Block)                      {}
 func (NopHandler) HandleSignEdit(*event.Context, string, string)                              {}
+func (NopHandler) HandleSleepReminder(*event.Context)                                         {}
 func (NopHandler) HandleItemPickup(*event.Context, item.Stack)                                {}
 func (NopHandler) HandleItemUse(*event.Context)                                               {}
 func (NopHandler) HandleItemUseOnBlock(*event.Context, cube.Pos, cube.Face, mgl64.Vec3)       {}