Implemented Books and Quills + Written Book

server/item/register.go

@@ -92,6 +92,8 @@ func init() {
 	world.RegisterItem(BlazeRod{})
 	world.RegisterItem(Bone{})
 	world.RegisterItem(Book{})
+	world.RegisterItem(WritableBook{})
+	world.RegisterItem(WrittenBook{})
 	world.RegisterItem(Bowl{})
 	world.RegisterItem(Charcoal{})
 	world.RegisterItem(DragonBreath{})

server/item/writable_book.go

@@ -0,0 +1,97 @@
+package item
+
+type WritableBook struct {
+	Pages []string
+}
+
+// Page returns a specific page from the book. If the page exists, it will return the content and true, otherwise
+// it will return an empty string and false.
+func (w WritableBook) Page(page uint) (string, bool) {
+	p := int(page)
+	if len(w.Pages) <= p {
+		return "", false
+	}
+	return w.Pages[p], true
+}
+
+// MaxCount always returns 1.
+func (w WritableBook) MaxCount() int {
+	return 1
+}
+
+// Exists checks to see weather a page exists or not
+func (w WritableBook) Exists(page uint) bool {
+	return len(w.Pages) > int(page)
+}
+
+// Set writes a page to the book, if the page doesn't exist it will be created. It will panic if the
+// text is longer then 256 characters. It will return the newly updated pages.
+func (w WritableBook) Set(page uint, text string) []string {
+	if len(text) > 256 {
+		panic("text longer then 256 bytes")
+	}
+	pages := w.Pages
+	if !w.Exists(page) {
+		newPages := make([]string, page+1)
+		copy(newPages, pages)
+		pages = newPages
+	}
+	pages[page] = text
+	return pages
+}
+
+// Swap swaps two different pages, it will panic if the largest of the two numbers doesn't exist. it will
+// return the newly updated pages.
+func (w WritableBook) Swap(page1, page2 uint) []string {
+	pages := w.Pages
+	if w.Exists(max(page1, page2)) {
+		panic("invalid page number")
+	}
+	content1 := pages[page1]
+	content2 := pages[page2]
+	pages[page1] = content2
+	pages[page2] = content1
+	return pages
+}
+
+// DecodeNBT ...
+func (w WritableBook) DecodeNBT(data map[string]any) any {
+	if pages, ok := data["pages"].([]any); ok {
+		for _, page := range pages {
+			if pageData, ok := page.(map[string]any); ok {
+				if text, ok := pageData["text"].(string); ok {
+					w.Pages = append(w.Pages, text)
+				}
+			}
+		}
+	}
+	return w
+}
+
+// EncodeNBT ...
+func (w WritableBook) EncodeNBT() map[string]any {
+	if len(w.Pages) == 0 {
+		return nil
+	}
+	data := map[string]any{}
+	var pages []any
+	for _, page := range w.Pages {
+		pages = append(pages, map[string]any{
+			"text": page,
+		})
+	}
+	data["pages"] = pages
+	return data
+}
+
+// max ...
+func max(a, b uint) uint {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func (w WritableBook) EncodeItem() (name string, meta int16) {
+	return "minecraft:writable_book", 0
+}

server/item/written_book.go

@@ -0,0 +1,62 @@
+package item
+
+type WrittenBook struct {
+	Title      string
+	Author     string
+	Generation uint
+	Glinted
+	Pages []string
+}
+
+// MaxCount always returns 1.
+func (w WrittenBook) MaxCount() int {
+	return 1
+}
+
+// Page returns a specific page from the book. If the page exists, it will return the content and true, otherwise
+// it will return an empty string and false.
+func (w WrittenBook) Page(page uint) (string, bool) {
+	p := int(page)
+	if len(w.Pages) <= p {
+		return "", false
+	}
+	return w.Pages[p], true
+}
+
+// DecodeNBT ...
+func (w WrittenBook) DecodeNBT(data map[string]any) any {
+	if pages, ok := data["pages"].([]map[string]string); ok {
+		for i, page := range pages {
+			w.Pages[i] = page["text"]
+		}
+	}
+	if v, ok := data["title"].(string); ok {
+		w.Title = v
+	}
+	if v, ok := data["author"].(string); ok {
+		w.Author = v
+	}
+	return w
+}
+
+// EncodeNBT ...
+func (w WrittenBook) EncodeNBT() map[string]any {
+	data := map[string]any{}
+	var pages []map[string]string
+	for _, page := range w.Pages {
+		pages = append(pages, map[string]string{
+			"text":      page,
+			"photoname": "",
+		})
+	}
+	data["pages"] = pages
+	data["author"] = w.Author
+	data["title"] = w.Title
+	data["generation"] = byte(w.Generation)
+	return data
+}
+
+// EncodeItem ...
+func (w WrittenBook) EncodeItem() (name string, meta int16) {
+	return "minecraft:written_book", 0
+}

server/session/handler_book_edit.go

@@ -0,0 +1,66 @@
+package session
+
+import (
+	"fmt"
+	"github.com/df-mc/dragonfly/server/item"
+	"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
+	"golang.org/x/exp/slices"
+)
+
+type BookEditHandler struct{}
+
+// Handle ...
+func (b BookEditHandler) Handle(p packet.Packet, s *Session) error {
+	pk := p.(*packet.BookEdit)
+	it, err := s.inv.Item(int(pk.InventorySlot))
+	if err != nil {
+		return fmt.Errorf("invalid inventory slot index %v", pk.InventorySlot)
+	}
+	book, ok := it.Item().(item.WritableBook)
+	if !ok {
+		return fmt.Errorf("inventory slot %v does not contain a writable book", pk.InventorySlot)
+	}
+	// check page number and text beforehand to reduce repetition, shouldn't matter as the default values
+	// match these constraints
+	page := uint(pk.PageNumber)
+	if page >= 50 {
+		return fmt.Errorf("page number %v is out of bounds", pk.PageNumber)
+	}
+	if len(pk.Text) > 256 {
+		return fmt.Errorf("text can not be longer than 256 bytes")
+	}
+	var pages []string
+	slot := int(pk.InventorySlot)
+	switch pk.ActionType {
+	case packet.BookActionReplacePage:
+		pages = book.Set(page, pk.Text)
+	case packet.BookActionAddPage:
+		if !book.Exists(page) {
+			return fmt.Errorf("may only come before a page which already exists")
+		}
+		if len(book.Pages) >= 50 {
+			return fmt.Errorf("unable to add page beyond 50")
+		}
+		pages = slices.Insert(book.Pages, int(page), pk.Text)
+	case packet.BookActionDeletePage:
+		if !book.Exists(page) {
+			return fmt.Errorf("page number %v does not exist", pk.PageNumber)
+		}
+		pages = slices.Delete(book.Pages, int(page), int(page+1))
+	case packet.BookActionSwapPages:
+		if pk.SecondaryPageNumber >= 50 {
+			return fmt.Errorf("page number out of bounds")
+		}
+		if !book.Exists(page) || !book.Exists(uint(pk.SecondaryPageNumber)) {
+			return fmt.Errorf("page numbers do not exist")
+		}
+		pages = book.Swap(page, uint(pk.SecondaryPageNumber))
+	case packet.BookActionSign:
+		// Error does not need to be handled as it's confirmed at the begging that this slot contains a writable book.
+		s.inv.SetItem(slot, item.NewStack(item.WrittenBook{Title: pk.Title, Author: pk.Author, Pages: book.Pages, Generation: 0}, 1))
+		return nil
+	}
+	// Error does not need to be handled as it's confirmed at the begging that this slot contains a writable book.
+	s.inv.SetItem(slot, item.NewStack(item.WritableBook{Pages: pages}, 1))
+	return nil
+}

server/session/session.go

@@ -434,6 +434,7 @@ func (s *Session) registerHandlers() {
 		packet.IDAnvilDamage:           nil,
 		packet.IDBlockActorData:        &BlockActorDataHandler{},
 		packet.IDBlockPickRequest:      &BlockPickRequestHandler{},
+		packet.IDBookEdit:              &BookEditHandler{},
 		packet.IDBossEvent:             nil,
 		packet.IDClientCacheBlobStatus: &ClientCacheBlobStatusHandler{},
 		packet.IDCommandRequest:        &CommandRequestHandler{},