Palette support 1

save/bitstorage.go

@@ -2,6 +2,8 @@ package save
 
 import (
 	"fmt"
+	pk "github.com/Tnze/go-mc/net/packet"
+	"io"
 	"math"
 )
 
@@ -128,3 +130,41 @@ func (b *BitStorage) Longs() []uint64 {
 	}
 	return b.data
 }
+
+func (b *BitStorage) ReadFrom(r io.Reader) (int64, error) {
+	var Len pk.VarInt
+	n, err := Len.ReadFrom(r)
+	if err != nil {
+		return n, err
+	}
+	if cap(b.data) >= int(Len) {
+		b.data = b.data[:Len]
+	} else {
+		b.data = make([]uint64, Len)
+	}
+	var v pk.Long
+	for i := range b.data {
+		nn, err := v.ReadFrom(r)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+		b.data[i] = uint64(v)
+	}
+	return n, nil
+}
+
+func (b *BitStorage) WriteTo(w io.Writer) (int64, error) {
+	n, err := pk.VarInt(len(b.data)).WriteTo(w)
+	if err != nil {
+		return n, err
+	}
+	for _, v := range b.data {
+		nn, err := pk.Long(v).WriteTo(w)
+		n += nn
+		if err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}

save/palette.go

@@ -3,25 +3,76 @@ package save
 import (
 	"io"
 
-	"github.com/Tnze/go-mc/nbt"
 	pk "github.com/Tnze/go-mc/net/packet"
 )
 
 type BlockState interface {
 }
 
+type PaletteContainer struct {
+	maps blockMaps
+	palette
+	BitStorage
+}
+
+func (p *PaletteContainer) ReadFrom(r io.Reader) (n int64, err error) {
+	var bits pk.UnsignedByte
+	n, err = bits.ReadFrom(r)
+	if err != nil {
+		return
+	}
+	switch bits {
+	case 0:
+		// TODO: SingleValuePalette
+	case 1, 2, 3, 4:
+		p.palette = &linearPalette{
+			onResize: nil,
+			maps:     p.maps,
+			bits:     4,
+		}
+	case 5, 6, 7, 8:
+		// TODO: HashMapPalette
+	default:
+		// TODO: GlobalPalette
+	}
+
+	nn, err := p.palette.ReadFrom(r)
+	n += nn
+	if err != nil {
+		return n, err
+	}
+
+	nn, err = p.BitStorage.ReadFrom(r)
+	n += nn
+	if err != nil {
+		return n, err
+	}
+	return n, nil
+}
+
+func (p *PaletteContainer) WriteTo(w io.Writer) (n int64, err error) {
+	return pk.Tuple{
+		pk.UnsignedByte(p.bits),
+		p.palette,
+		p.BitStorage,
+	}.WriteTo(w)
+}
+
 type palette interface {
-	id(v BlockState) int
-	value(i int) BlockState
 	pk.FieldEncoder
 	pk.FieldDecoder
-	read(r nbt.DecoderReader) (int, error)
+	id(v BlockState) int
+	value(i int) BlockState
+}
+
+type blockMaps interface {
+	getID(state BlockState) (id int)
+	getValue(id int) (state BlockState)
 }
 
 type linearPalette struct {
 	onResize func(n int, v BlockState) int
-	sToID    map[BlockState]int
-	idTos    map[int]BlockState
+	maps     blockMaps
 	values   []BlockState
 	bits     int
 }
@@ -57,7 +108,7 @@ func (l *linearPalette) ReadFrom(r io.Reader) (n int64, err error) {
 		} else {
 			n += nn
 		}
-		l.values[i] = l.idTos[int(value)]
+		l.values[i] = l.maps.getValue(int(value))
 	}
 	return
 }
@@ -67,7 +118,7 @@ func (l *linearPalette) WriteTo(w io.Writer) (n int64, err error) {
 		return
 	}
 	for _, v := range l.values {
-		if nn, err := pk.VarInt(l.sToID[v]).WriteTo(w); err != nil {
+		if nn, err := pk.VarInt(l.maps.getID(v)).WriteTo(w); err != nil {
 			return n + nn, err
 		} else {
 			n += nn
@@ -76,6 +127,8 @@ func (l *linearPalette) WriteTo(w io.Writer) (n int64, err error) {
 	return
 }
 
-func (l *linearPalette) read(r nbt.DecoderReader) (int, error) {
-	panic("not implemented yet")
+type hashMapPalette struct {
+	maps   blockMaps
+	values map[int]BlockState
+	bits   int
 }