Implementation of a view layer

Co-authored-by: RestartFU <[email protected]>

server/player/player.go

@@ -2286,6 +2286,11 @@ func (p *Player) Tick(w *world.World, current int64) {
 	}
 }
 
+// ViewLayer ...
+func (p *Player) ViewLayer() *world.ViewLayer {
+	return p.session().ViewLayer()
+}
+
 // tickAirSupply tick's the player's air supply, consuming it when underwater, and replenishing it when out of water.
 func (p *Player) tickAirSupply(w *world.World) {
 	if !p.canBreathe(w) {

server/session/session.go

@@ -81,6 +81,8 @@ type Session struct {
 
 	joinMessage, quitMessage string
 
+	viewLayer *world.ViewLayer
+
 	closeBackground chan struct{}
 }
 
@@ -164,6 +166,7 @@ func New(conn Conn, maxChunkRadius int, log Logger, joinMessage, quitMessage str
 		heldSlot:               atomic.NewUint32(0),
 		joinMessage:            joinMessage,
 		quitMessage:            quitMessage,
+		viewLayer:              world.NewViewLayer(),
 		openedWindow:           *atomic.NewValue(inventory.New(1, nil)),
 	}
 
@@ -232,6 +235,7 @@ func (s *Session) Close() error {
 // close closes the session, which in turn closes the controllable and the connection that the session
 // manages.
 func (s *Session) close() {
+	_ = s.viewLayer.Close()
 	_ = s.c.Close()
 
 	// Move UI inventory items to the main inventory.

server/session/view_layer.go

@@ -0,0 +1,11 @@
+package session
+
+import "github.com/df-mc/dragonfly/server/world"
+
+type LayerViewer interface {
+	ViewLayer() *world.ViewLayer
+}
+
+func (s *Session) ViewLayer() *world.ViewLayer {
+	return s.viewLayer
+}

server/session/world.go

@@ -908,9 +908,19 @@ func (s *Session) ViewEntityAction(e world.Entity, a world.EntityAction) {
 
 // ViewEntityState ...
 func (s *Session) ViewEntityState(e world.Entity) {
+	metadata := s.parseEntityMetadata(e)
+	if v, ok := e.(LayerViewer); ok {
+		if nt := s.viewLayer.NameTag(v); len(nt) > 0 {
+			metadata[protocol.EntityDataKeyName] = nt
+		}
+		invisFlag := metadata.Flag(protocol.EntityDataKeyFlags, protocol.EntityDataFlagInvisible)
+		if invis := s.viewLayer.Invisible(v); !invisFlag && invis {
+			metadata.SetFlag(protocol.EntityDataKeyFlags, protocol.EntityDataFlagInvisible)
+		}
+	}
 	s.writePacket(&packet.SetActorData{
 		EntityRuntimeID: s.entityRuntimeID(e),
-		EntityMetadata:  s.parseEntityMetadata(e),
+		EntityMetadata:  metadata,
 	})
 }
 

server/world/view_layer.go

@@ -0,0 +1,92 @@
+package world
+
+import (
+	"sync"
+)
+
+type LayerViewer interface {
+	ViewLayer() *ViewLayer
+}
+
+type Layer struct {
+	nameTag   string
+	invisible bool
+}
+
+// ViewLayer is a view layer that can be used to add a layer to the view of a player.
+type ViewLayer struct {
+	viewerMu sync.RWMutex
+	viewers  map[LayerViewer]Layer
+}
+
+// NewViewLayer returns a new ViewLayer.
+func NewViewLayer() *ViewLayer {
+	return &ViewLayer{
+		viewers: map[LayerViewer]Layer{},
+	}
+}
+
+// Viewers returns all viewers of the view layer.
+func (v *ViewLayer) Viewers() []LayerViewer {
+	v.viewerMu.Lock()
+	defer v.viewerMu.Unlock()
+	viewers := make([]LayerViewer, 0, len(v.viewers))
+	for viewer := range v.viewers {
+		viewers = append(viewers, viewer)
+	}
+	return viewers
+}
+
+// ViewNameTag adds a name tag to a viewer.
+func (v *ViewLayer) ViewNameTag(viewer LayerViewer, nameTag string) {
+	v.viewerMu.Lock()
+	defer v.viewerMu.Unlock()
+
+	l := v.viewers[viewer]
+	l.nameTag = nameTag
+	v.viewers[viewer] = l
+}
+
+// NameTag returns the name tag of a viewer.
+func (v *ViewLayer) NameTag(viewer LayerViewer) string {
+	v.viewerMu.Lock()
+	defer v.viewerMu.Unlock()
+	return v.viewers[viewer].nameTag
+}
+
+// ViewVisible makes a viewer be visible.
+func (v *ViewLayer) ViewVisible(viewer LayerViewer) {
+	v.viewerMu.Lock()
+	defer v.viewerMu.Unlock()
+
+	l := v.viewers[viewer]
+	l.invisible = false
+	v.viewers[viewer] = l
+}
+
+// ViewInvisible makes a viewer be invisible.
+func (v *ViewLayer) ViewInvisible(viewer LayerViewer) {
+	v.viewerMu.Lock()
+	defer v.viewerMu.Unlock()
+
+	l := v.viewers[viewer]
+	l.invisible = true
+	v.viewers[viewer] = l
+}
+
+// Invisible returns the invisibility of a viewer.
+func (v *ViewLayer) Invisible(viewer LayerViewer) bool {
+	v.viewerMu.Lock()
+	defer v.viewerMu.Unlock()
+	return v.viewers[viewer].invisible
+}
+
+// Close closes the view layer.
+func (v *ViewLayer) Close() error {
+	v.viewerMu.Lock()
+	defer v.viewerMu.Unlock()
+	for viewer := range v.viewers {
+		delete(v.viewers, viewer)
+	}
+	return nil
+}