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

server/entity/direction.go

@@ -1,10 +1,11 @@
 package entity
 
 import (
+	"math"
+
 	"github.com/df-mc/dragonfly/server/block/cube"
 	"github.com/df-mc/dragonfly/server/world"
 	"github.com/go-gl/mathgl/mgl64"
-	"math"
 )
 
 // Facing returns the horizontal direction that an entity is facing.
@@ -27,6 +28,22 @@ func Facing(e world.Entity) cube.Direction {
 	return 0
 }
 
+// Bearing splits the 360 degree to sections and returns the section number by yaw.
+func Bearing(yaw float64, max int64) int64 {
+	// Ported from from https://stackoverflow.com/a/38505683.
+	// https://code.sololearn.com/cLibMMRbbnb2.
+	roundedYaw := int64(math.Round(yaw))
+
+	divisor := 360 / max
+	coci := roundedYaw / divisor
+	resto := roundedYaw % divisor
+	if resto <= divisor/2 {
+		return coci % max
+	} else {
+		return (coci + 1) % max
+	}
+}
+
 // DirectionVector returns a vector that describes the direction of the entity passed. The length of the Vec3
 // returned is always 1.
 func DirectionVector(e world.Entity) mgl64.Vec3 {

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/map.go

@@ -0,0 +1,46 @@
+package item
+
+import (
+	"github.com/df-mc/dragonfly/server/world"
+)
+
+type MapItem interface {
+	BaseMap() 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 ...
+func (m BaseMap) BaseMap() 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
@@ -463,6 +464,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,
@@ -546,3 +548,80 @@ 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
+	)
+	for e := range d.TrackEntities {
+		// Since entity IDs are not reused per world, I am not checking world here.
+		trackeds = append(trackeds, protocol.MapTrackedObject{
+			Type:           protocol.MapObjectTypeEntity,
+			EntityUniqueID: int64(s.entityRuntimeID(e)),
+		})
+	}
+	if data.World() == s.c.World() {
+		for p := range d.TrackBlocks {
+			trackeds = append(trackeds, protocol.MapTrackedObject{
+				Type:          protocol.MapObjectTypeBlock,
+				BlockPosition: protocol.BlockPos{int32(p[0]), int32(p[1]), int32(p[2])},
+			})
+		}
+	}
+
+	s.writePacket(&packet.ClientBoundMapItemData{
+		MapID:          mapID,
+		UpdateFlags:    updateFlag,
+		Dimension:      byte(data.World().Dimension().EncodeDimension()),
+		LockedMap:      d.Locked,
+		Scale:          d.Scale,
+		TrackedObjects: trackeds,
+		// Decorations is a list of fixed decorations located on the map. The decorations will not change
+		// client-side, unless the server updates them.
+		Decorations: []protocol.MapDecoration{},
+
+		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
+}