Implemented beds

server/block/bed.go

@@ -0,0 +1,232 @@
+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
+	sourceWaterDisplacer
+
+	// 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. It is only set for the Head part of the bed.
+	User item.User
+}
+
+// MaxCount always returns 1.
+func (Bed) MaxCount() int {
+	return 1
+}
+
+// Model ...
+func (Bed) Model() world.BlockModel {
+	return model.Bed{}
+}
+
+// SideClosed ...
+func (Bed) SideClosed(cube.Pos, cube.Pos, *world.World) bool {
+	return false
+}
+
+// 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()
+		}
+	})
+}
+
+// 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.Rotation().Direction()
+
+	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>%%tile.bed.tooFar</grey>"))
+		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>%%tile.bed.respawnSet</grey>"))
+		s.Messaget(text.Colourf("<grey>%%tile.bed.noSleep</grey>"))
+		return true
+	}
+	if headSide.User != nil {
+		s.Messaget(text.Colourf("<grey>%%tile.bed.respawnSet</grey>"))
+		s.Messaget(text.Colourf("<grey>%%tile.bed.occupied</grey>"))
+		return true
+	}
+
+	s.Sleep(headPos)
+	return true
+}
+
+// EntityLand ...
+func (b Bed) EntityLand(_ cube.Pos, _ *world.World, e world.Entity, distance *float64) {
+	if s, ok := e.(sneakingEntity); ok && s.Sneaking() {
+		// If the entity is sneaking, the fall distance and velocity stay the same.
+		return
+	}
+	if _, ok := e.(fallDistanceEntity); ok {
+		*distance *= 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.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/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

@@ -116,6 +116,7 @@ func init() {
 	registerAll(allBanners())
 	registerAll(allBarrels())
 	registerAll(allBasalt())
+	registerAll(allBeds())
 	registerAll(allBeetroot())
 	registerAll(allBlackstone())
 	registerAll(allBlastFurnaces())
@@ -349,6 +350,7 @@ func init() {
 	}
 	for _, c := range item.Colours() {
 		world.RegisterItem(Banner{Colour: c})
+		world.RegisterItem(Bed{Colour: c})
 		world.RegisterItem(Carpet{Colour: c})
 		world.RegisterItem(ConcretePowder{Colour: c})
 		world.RegisterItem(Concrete{Colour: c})

server/player/handler.go

@@ -108,6 +108,8 @@ 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)
+	// HandleSleep handles the player going to sleep. ctx.Cancel() may be called to cancel the sleep.
+	HandleSleep(ctx *event.Context, sendReminder *bool)
 	// 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
@@ -155,6 +157,7 @@ func (NopHandler) HandleBlockBreak(*event.Context, cube.Pos, *[]item.Stack, *int
 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) HandleSleep(*event.Context, *bool)                                          {}
 func (NopHandler) HandleItemPickup(*event.Context, item.Stack)                                {}
 func (NopHandler) HandleItemUse(*event.Context)                                               {}
 func (NopHandler) HandleItemUseOnBlock(*event.Context, cube.Pos, cube.Face, mgl64.Vec3)       {}