Filled maps (non-persistent, not rendered from terrain)

server/item/filled_map.go

@@ -0,0 +1,10 @@
+package item
+
+type FilledMap struct {
+	BaseMap
+}
+
+// EncodeItem ...
+func (m FilledMap) EncodeItem() (name string, meta int16) {
+	return "minecraft:filled_map", 0
+}

server/item/locked_map.go

@@ -0,0 +1,10 @@
+package item
+
+type LockedMap struct {
+	BaseMap
+}
+
+// EncodeItem ...
+func (m LockedMap) EncodeItem() (name string, meta int16) {
+	return "minecraft:filled_map", 6
+}

server/item/map.go

@@ -0,0 +1,46 @@
+package item
+
+import (
+	"github.com/df-mc/dragonfly/server/world"
+)
+
+type MapItem interface {
+	AsBaseMap() *BaseMap
+}
+
+type BaseMap struct {
+	// IsInit has unknown functionality (referring to the Minecraft Wiki).
+	IsInit bool
+	// NameIndex is the index of the map's name.
+	NameIndex int32
+	// DisplayPlayers controls whether the map displays player markers (depends on Decorations and TrackedObjects in the map data).
+	DisplayPlayers bool
+
+	*world.ViewableMapData
+}
+
+// DecodeNBT ...
+func (m BaseMap) DecodeNBT(data map[string]any) any {
+	m.IsInit, _ = data["map_is_init"].(bool)
+	m.NameIndex, _ = data["map_name_index"].(int32)
+	m.DisplayPlayers, _ = data["map_display_players"].(bool)
+	/*
+		if id, ok := data["map_uuid"].(int64); ok {
+		} TODO: Persisted map data.
+	*/
+	return m
+}
+
+// EncodeNBT ...
+func (m BaseMap) EncodeNBT() map[string]any {
+	data := m.ViewableMapData.EncodeItemNBT()
+	data["map_is_init"] = m.IsInit
+	data["map_name_index"] = m.NameIndex
+	data["map_display_players"] = m.DisplayPlayers
+	return data
+}
+
+// BaseMap returns the pointer instead of a value copy.
+func (m *BaseMap) AsBaseMap() *BaseMap {
+	return m
+}

server/item/ocean_explorer_map.go

@@ -0,0 +1,10 @@
+package item
+
+type OceanMap struct {
+	BaseMap
+}
+
+// EncodeItem ...
+func (m OceanMap) EncodeItem() (name string, meta int16) {
+	return "minecraft:filled_map", 3
+}

server/item/register.go

@@ -151,4 +151,9 @@ func init() {
 	world.RegisterItem(AmethystShard{})
 	world.RegisterItem(DiscFragment{})
 	world.RegisterItem(EchoShard{})
+
+	world.RegisterItem(FilledMap{})
+	world.RegisterItem(OceanMap{})
+	world.RegisterItem(WoodlandExplorerMap{})
+	world.RegisterItem(TreasureMap{})
 }

server/item/treasure_map.go

@@ -0,0 +1,10 @@
+package item
+
+type TreasureMap struct {
+	BaseMap
+}
+
+// EncodeItem ...
+func (m TreasureMap) EncodeItem() (name string, meta int16) {
+	return "minecraft:filled_map", 5
+}

server/item/woodland_explorer_map.go

@@ -0,0 +1,10 @@
+package item
+
+type WoodlandExplorerMap struct {
+	BaseMap
+}
+
+// EncodeItem ...
+func (m WoodlandExplorerMap) EncodeItem() (name string, meta int16) {
+	return "minecraft:filled_map", 4
+}

server/session/handler_map_info_request.go

@@ -0,0 +1,30 @@
+package session
+
+import (
+	"fmt"
+
+	"github.com/df-mc/dragonfly/server/item"
+	"github.com/df-mc/dragonfly/server/world"
+	"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
+)
+
+// MapInfoRequestHandler handles the MapInfoRequest packet.
+type MapInfoRequestHandler struct {
+}
+
+// Handle ...
+func (h *MapInfoRequestHandler) Handle(p packet.Packet, s *Session) error {
+	var (
+		pk      = p.(*packet.MapInfoRequest)
+		ok      bool
+		mapItem item.MapItem
+	)
+	if mapItem, ok = s.canAccessMapData(pk.MapID); !ok {
+		return fmt.Errorf("client requests info of map %v while he does not have the corresponding map item in inventory, off hand inventory, UI inventory or armour inventory", pk.MapID)
+	}
+
+	mapItem.BaseMap().AddViewer(s)
+	s.SendMapData(packet.MapUpdateFlagInitialisation, pk.MapID, world.MapPixelsChunk{}, mapItem.BaseMap().ViewableMapData)
+
+	return nil
+}

server/session/session.go

@@ -4,6 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
+	"net"
+	"sync"
+	"time"
+
 	"github.com/df-mc/atomic"
 	"github.com/df-mc/dragonfly/server/block"
 	"github.com/df-mc/dragonfly/server/block/cube"
@@ -21,10 +26,6 @@ import (
 	"github.com/sandertv/gophertunnel/minecraft/protocol/login"
 	"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
 	"github.com/sandertv/gophertunnel/minecraft/text"
-	"io"
-	"net"
-	"sync"
-	"time"
 )
 
 // Session handles incoming packets from connections and sends outgoing packets by providing a thin layer
@@ -447,6 +448,7 @@ func (s *Session) registerHandlers() {
 		packet.IDItemFrameDropItem:     nil,
 		packet.IDItemStackRequest:      &ItemStackRequestHandler{changes: make(map[byte]map[byte]changeInfo), responseChanges: map[int32]map[*inventory.Inventory]map[byte]responseChange{}},
 		packet.IDLevelSoundEvent:       &LevelSoundEventHandler{},
+		packet.IDMapInfoRequest:        &MapInfoRequestHandler{},
 		packet.IDMobEquipment:          &MobEquipmentHandler{},
 		packet.IDModalFormResponse:     &ModalFormResponseHandler{forms: make(map[uint32]form.Form)},
 		packet.IDMovePlayer:            nil,
@@ -528,3 +530,95 @@ func (s *Session) sendAvailableEntities() {
 	}
 	s.writePacket(&packet.AvailableActorIdentifiers{SerialisedEntityIdentifiers: serializedEntityData})
 }
+
+// ViewMapDataChange writes *packet.ClientBoundMapItemData if session still has access to the data.
+func (s *Session) ViewMapDataChange(updateFlag uint32, mapID int64, pixelsChunk world.MapPixelsChunk, data *world.ViewableMapData) {
+	if _, ok := s.canAccessMapData(mapID); !ok {
+		data.RemoveViewer(s)
+		return
+	}
+
+	s.SendMapData(updateFlag, mapID, pixelsChunk, data)
+}
+
+// SendMapData writes *packet.ClientBoundMapItemData.
+func (s *Session) SendMapData(updateFlag uint32, mapID int64, pixelsChunk world.MapPixelsChunk, data *world.ViewableMapData) {
+	var (
+		d           = data.MapData()
+		trackeds    []protocol.MapTrackedObject
+		decorations []protocol.MapDecoration
+	)
+	for e, offsets := range d.TrackEntities {
+		trackeds = append(trackeds, protocol.MapTrackedObject{
+			Type:           protocol.MapObjectTypeEntity,
+			EntityUniqueID: int64(s.entityRuntimeID(e)),
+		})
+
+		if data.World() == s.c.World() {
+			yaw, _ := e.Rotation()
+			decorations = append(decorations, protocol.MapDecoration{
+				Type:     protocol.MapObjectTypeEntity,
+				Rotation: byte((yaw*2+45)/45 - 1), // Credit to SOFe#4765.
+				X:        offsets[0],
+				Y:        offsets[1],
+				Label:    e.Name(),
+			})
+		}
+	}
+	if data.World() == s.c.World() {
+		for p, offsets := range d.TrackBlocks {
+			trackeds = append(trackeds, protocol.MapTrackedObject{
+				Type:          protocol.MapObjectTypeBlock,
+				BlockPosition: protocol.BlockPos{int32(p[0]), int32(p[1]), int32(p[2])},
+			})
+
+			decorations = append(decorations, protocol.MapDecoration{
+				Type: protocol.MapObjectTypeEntity,
+				X:    offsets[0],
+				Y:    offsets[1],
+			})
+		}
+	}
+
+	s.writePacket(&packet.ClientBoundMapItemData{
+		MapID:          mapID,
+		UpdateFlags:    updateFlag,
+		Dimension:      byte(data.World().Dimension().EncodeDimension()),
+		LockedMap:      d.Locked,
+		Scale:          d.Scale,
+		TrackedObjects: trackeds,
+		Decorations:    decorations,
+
+		Height:  pixelsChunk.Height,
+		Width:   pixelsChunk.Width,
+		XOffset: pixelsChunk.XOffset,
+		YOffset: pixelsChunk.YOffset,
+		Pixels:  pixelsChunk.Pixels,
+	})
+
+}
+
+func (s *Session) canAccessMapData(mapID int64) (item.MapItem, bool) {
+	var (
+		mapItem item.MapItem
+		ok      bool
+	)
+	for _, inv := range []*inventory.Inventory{
+		s.inv,
+		s.offHand,
+		s.ui,
+		s.armour.Inventory(),
+	} {
+		if inv.ContainsItemFunc(1, func(stack item.Stack) bool {
+			if mapItem, ok = stack.Item().(item.MapItem); ok {
+				return mapItem.BaseMap().MapIDEquals(mapID)
+			}
+
+			return false // Item is not map.
+		}) {
+			return mapItem, true
+		}
+	}
+
+	return nil, false
+}