Implemented Books and Quills + Written Book

server/item/book_and_quill.go

@@ -0,0 +1,90 @@
+package item
+
+// BookAndQuill is an item used to write WrittenBook(s).
+type BookAndQuill struct {
+	// Pages represents the pages within the book.
+	Pages []string
+}
+
+// MaxCount always returns 1.
+func (w BookAndQuill) MaxCount() int {
+	return 1
+}
+
+// Page returns a specific page from the book and true when the page exists. It will otherwise return an empty string
+// and false.
+func (w BookAndQuill) Page(page int) (string, bool) {
+	if page < 0 || len(w.Pages) <= page {
+		return "", false
+	}
+	return w.Pages[page], true
+}
+
+// SetPage 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 a new book representing this data.
+func (w BookAndQuill) SetPage(page int, text string) BookAndQuill {
+	if page < 0 || page >= 50 {
+		panic("invalid page number")
+	}
+	if len(text) > 256 {
+		panic("text longer then 256 bytes")
+	}
+	if _, ok := w.Page(page); !ok {
+		pages := make([]string, page+1)
+		copy(pages, w.Pages)
+		w.Pages = pages
+	}
+	w.Pages[page] = text
+	return w
+}
+
+// SwapPages 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 BookAndQuill) SwapPages(pageOne, pageTwo int) BookAndQuill {
+	if pageOne < 0 || pageTwo < 0 {
+		panic("negative page number")
+	}
+	if _, ok := w.Page(max(pageOne, pageTwo)); !ok {
+		panic("invalid page number")
+	}
+	temp := w.Pages[pageOne]
+	w.Pages[pageOne] = w.Pages[pageTwo]
+	w.Pages[pageTwo] = temp
+	return w
+}
+
+// DecodeNBT ...
+func (w BookAndQuill) 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 BookAndQuill) EncodeNBT() map[string]any {
+	pages := make([]any, 0, len(w.Pages))
+	for _, page := range w.Pages {
+		pages = append(pages, map[string]any{"text": page})
+	}
+	return map[string]any{"pages": pages}
+}
+
+// EncodeItem ...
+func (w BookAndQuill) EncodeItem() (name string, meta int16) {
+	return "minecraft:writable_book", 0
+}
+
+// max ...
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

server/item/register.go

@@ -20,6 +20,7 @@ func init() {
 	world.RegisterItem(BlazeRod{})
 	world.RegisterItem(BoneMeal{})
 	world.RegisterItem(Bone{})
+	world.RegisterItem(BookAndQuill{})
 	world.RegisterItem(Book{})
 	world.RegisterItem(BottleOfEnchanting{})
 	world.RegisterItem(Bowl{})
@@ -118,6 +119,7 @@ func init() {
 	world.RegisterItem(TurtleShell{})
 	world.RegisterItem(WarpedFungusOnAStick{})
 	world.RegisterItem(Wheat{})
+	world.RegisterItem(WrittenBook{})
 	for _, t := range ArmourTiers() {
 		world.RegisterItem(Helmet{Tier: t})
 		world.RegisterItem(Chestplate{Tier: t})

server/item/written_book.go

@@ -0,0 +1,75 @@
+package item
+
+// WrittenBook is the item created after a book and quill is signed. It appears the same as a regular book, but
+// without the quill, and has an enchanted-looking glint.
+type WrittenBook struct {
+	// Title is the title of the book.
+	Title string
+	// Author is the author of the book.
+	Author string
+	// Generation is the copy tier of the book. 0 = original, 1 = copy of original,
+	// 2 = copy of copy.
+	Generation WrittenBookGeneration
+	// Pages represents the pages within the book.
+	Pages []string
+}
+
+// MaxCount always returns 1.
+func (w WrittenBook) MaxCount() int {
+	return 1
+}
+
+// Page returns a specific page from the book and true when the page exists. It will otherwise return an empty string
+// and false.
+func (w WrittenBook) Page(page int) (string, bool) {
+	if page < 0 || len(w.Pages) <= page {
+		return "", false
+	}
+	return w.Pages[page], true
+}
+
+// DecodeNBT ...
+func (w WrittenBook) DecodeNBT(data map[string]any) any {
+	if pages, ok := data["pages"].([]any); ok {
+		w.Pages = make([]string, len(pages))
+		for i, page := range pages {
+			w.Pages[i] = page.(map[string]any)["text"].(string)
+		}
+	}
+	if v, ok := data["title"].(string); ok {
+		w.Title = v
+	}
+	if v, ok := data["author"].(string); ok {
+		w.Author = v
+	}
+	if v, ok := data["generation"].(uint8); ok {
+		switch v {
+		case 0:
+			w.Generation = OriginalGeneration()
+		case 1:
+			w.Generation = CopyGeneration()
+		case 2:
+			w.Generation = CopyOfCopyGeneration()
+		}
+	}
+	return w
+}
+
+// EncodeNBT ...
+func (w WrittenBook) EncodeNBT() map[string]any {
+	pages := make([]any, 0, len(w.Pages))
+	for _, page := range w.Pages {
+		pages = append(pages, map[string]any{"text": page})
+	}
+	return map[string]any{
+		"pages":      pages,
+		"author":     w.Author,
+		"title":      w.Title,
+		"generation": w.Generation.Uint8(),
+	}
+}
+
+// EncodeItem ...
+func (w WrittenBook) EncodeItem() (name string, meta int16) {
+	return "minecraft:written_book", 0
+}

server/item/written_book_generation.go

@@ -0,0 +1,41 @@
+package item
+
+// WrittenBookGeneration represents a WrittenBook generation.
+type WrittenBookGeneration struct {
+	generation
+}
+
+type generation uint8
+
+// OriginalGeneration is the original WrittenBook.
+func OriginalGeneration() WrittenBookGeneration {
+	return WrittenBookGeneration{0}
+}
+
+// CopyGeneration is a copy of the original WrittenBook.
+func CopyGeneration() WrittenBookGeneration {
+	return WrittenBookGeneration{1}
+}
+
+// CopyOfCopyGeneration is a copy of a copy of the original WrittenBook.
+func CopyOfCopyGeneration() WrittenBookGeneration {
+	return WrittenBookGeneration{2}
+}
+
+// Uint8 returns the generation as a uint8.
+func (g generation) Uint8() uint8 {
+	return uint8(g)
+}
+
+// String ...
+func (g generation) String() string {
+	switch g {
+	case 0:
+		return "original"
+	case 1:
+		return "copy of original"
+	case 2:
+		return "copy of copy"
+	}
+	panic("unknown written book generation")
+}

server/session/handler_book_edit.go

@@ -0,0 +1,76 @@
+package session
+
+import (
+	"fmt"
+	"github.com/df-mc/dragonfly/server/item"
+	"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
+	"golang.org/x/exp/slices"
+)
+
+// BookEditHandler handles the BookEdit packet.
+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.BookAndQuill)
+	if !ok {
+		return fmt.Errorf("inventory slot %v does not contain a writable book", pk.InventorySlot)
+	}
+
+	page := int(pk.PageNumber)
+	if page >= 50 || page < 0 {
+		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")
+	}
+
+	slot := int(pk.InventorySlot)
+	switch pk.ActionType {
+	case packet.BookActionReplacePage:
+		book = book.SetPage(page, pk.Text)
+	case packet.BookActionAddPage:
+		if len(book.Pages) >= 50 {
+			return fmt.Errorf("unable to add page beyond 50")
+		}
+		if page >= len(book.Pages) && page <= len(book.Pages)+2 {
+			book = book.SetPage(page, "")
+			break
+		}
+		if _, ok := book.Page(page); !ok {
+			return fmt.Errorf("unable to insert page at %v", pk.PageNumber)
+		}
+		book = item.BookAndQuill{Pages: slices.Insert(book.Pages, page, pk.Text)}
+	case packet.BookActionDeletePage:
+		if _, ok := book.Page(page); !ok {
+			// We break here instead of returning an error because the client can be a page or two ahead in the UI then
+			// the actual pages representation server side. The client still sends the deletion indexes.
+			break
+		}
+		book = item.BookAndQuill{Pages: slices.Delete(book.Pages, page, page+1)}
+	case packet.BookActionSwapPages:
+		if pk.SecondaryPageNumber >= 50 {
+			return fmt.Errorf("page number out of bounds")
+		}
+		_, ok := book.Page(page)
+		_, ok2 := book.Page(int(pk.SecondaryPageNumber))
+		if !ok || !ok2 {
+			// We break here instead of returning an error because the client can try to swap pages that don't exist.
+			// This happens as a result of the client being a page or two ahead in the UI then the actual pages
+			// representation server side. The client still sends the swap indexes.
+			break
+		}
+		book = book.SwapPages(page, int(pk.SecondaryPageNumber))
+	case packet.BookActionSign:
+		_ = s.inv.SetItem(slot, item.NewStack(item.WrittenBook{Title: pk.Title, Author: pk.Author, Pages: book.Pages, Generation: item.OriginalGeneration()}, 1))
+		return nil
+	}
+	_ = s.inv.SetItem(slot, item.NewStack(book, 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{},