PaletteContainer

examples/frameworkServer/Dimension.snbt

@@ -1,17 +0,0 @@
-{
-	piglin_safe: 0b,
-	natural: 1b,
-	ambient_light: 0.0f,
-	infiniburn: "minecraft:infiniburn_overworld",
-	respawn_anchor_works: 0b,
-	has_skylight: 1b,
-	bed_works: 1b,
-	effects: "minecraft:overworld",
-	has_raids: 1b,
-	min_y: 0,
-	height: 256,
-	logical_height: 256,
-	coordinate_scale: 1.0d,
-	ultrawarm: 0b,
-	has_ceiling: 0b
-}

examples/frameworkServer/main.go

@@ -8,18 +8,9 @@ import (
 	"os"
 
 	"github.com/Tnze/go-mc/chat"
-	"github.com/Tnze/go-mc/data/packetid"
-	"github.com/Tnze/go-mc/nbt"
-	"github.com/Tnze/go-mc/net"
-	pk "github.com/Tnze/go-mc/net/packet"
 	"github.com/Tnze/go-mc/server"
-	"github.com/google/uuid"
 )
 
-type MyServer struct {
-	playerList *server.PlayerList
-}
-
 const MaxPlayer = 20
 const IconPath = "./server-icon.png"
 
@@ -31,61 +22,24 @@ func main() {
 	if err != nil {
 		log.Fatalf("Set server info error: %v", err)
 	}
-	ms := MyServer{
+	defaultDimension := server.NewSimpleDim(16)
-		playerList: playerList,
+	defaultDimension.LoadChunk(server.ChunkPos{X: 0, Z: 0}, server.EmptyChunk(16))
-	}
-
 	s := server.Server{
 		ListPingHandler: serverInfo,
 		LoginHandler: &server.MojangLoginHandler{
 			OnlineMode: true,
 			Threshold:  256,
 		},
-		GamePlay: &ms,
+		GamePlay: &server.Game{
+			Dim:        defaultDimension,
+			PlayerList: playerList,
+		},
 	}
 	if err := s.Listen(":25565"); err != nil {
 		log.Fatalf("Listen error: %v", err)
 	}
 }
 
-func (m *MyServer) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net.Conn) {
-	// Add player into PlayerList
-	remove := m.playerList.TryInsert(server.PlayerSample{
-		Name: name,
-		ID:   id,
-	})
-	if remove == nil {
-		err := conn.WritePacket(pk.Marshal(packetid.ClientboundDisconnect,
-			chat.TranslateMsg("multiplayer.disconnect.server_full"),
-		))
-		if err != nil {
-			log.Printf("Write packet fail: %v", err)
-		}
-		return
-	}
-	defer remove()
-
-	if err := m.joinGame(conn); err != nil {
-		log.Printf("Write packet fail: %v", err)
-		return
-	}
-	if err := m.playerPositionAndLook(conn); err != nil {
-		log.Printf("Write packet fail: %v", err)
-		return
-	}
-
-	var p pk.Packet
-	for {
-		err := conn.ReadPacket(&p)
-		if err != nil {
-			log.Printf("Read packet fail: %v", err)
-			break
-		}
-
-		log.Printf("Read packet: %#X", p.ID)
-	}
-}
-
 func readIcon() image.Image {
 	f, err := os.Open(IconPath)
 	// if the file doesn't exist, return nil
@@ -102,41 +56,3 @@ func readIcon() image.Image {
 	}
 	return icon
 }
-
-//go:embed DimensionCodec.snbt
-var dimensionCodecSNBT string
-
-//go:embed Dimension.snbt
-var dimensionSNBT string
-
-func (m *MyServer) joinGame(conn *net.Conn) error {
-	return conn.WritePacket(pk.Marshal(packetid.ClientboundLogin,
-		pk.Int(0),          // EntityID
-		pk.Boolean(false),  // Is hardcore
-		pk.UnsignedByte(1), // Gamemode
-		pk.Byte(1),         // Previous Gamemode
-		pk.VarInt(1),       // World Count
-		pk.Ary{Len: 1, Ary: []pk.Identifier{"world"}},      // World Names
-		pk.NBT(nbt.StringifiedMessage(dimensionCodecSNBT)), // Dimension codec
-		pk.NBT(nbt.StringifiedMessage(dimensionSNBT)),      // Dimension
-		pk.Identifier("world"),                             // World Name
-		pk.Long(0),                                         // Hashed Seed
-		pk.VarInt(MaxPlayer),                               // Max Players
-		pk.VarInt(15),                                      // View Distance
-		pk.VarInt(15),                                      // Simulation Distance
-		pk.Boolean(false),                                  // Reduced Debug Info
-		pk.Boolean(true),                                   // Enable respawn screen
-		pk.Boolean(false),                                  // Is Debug
-		pk.Boolean(true),                                   // Is Flat
-	))
-}
-
-func (m *MyServer) playerPositionAndLook(conn *net.Conn) error {
-	return conn.WritePacket(pk.Marshal(packetid.ClientboundPlayerPosition,
-		pk.Double(0), pk.Double(0), pk.Double(0), // XYZ
-		pk.Float(0), pk.Float(0), // Yaw Pitch
-		pk.Byte(0),        // flag
-		pk.VarInt(0),      // TP ID
-		pk.Boolean(false), // Dismount vehicle
-	))
-}

save/bitstorage.go

@@ -26,7 +26,7 @@ type BitStorage struct {
 //
 // The "bits" is the number of bits per value, which can be calculated by math/bits.Len()
 // The "length" is the number of values.
-// The "data" is optional for initializing. Panic if data != nil && len(data) != BitStorageSize(bits, length).
+// The "data" is optional for initializing. Panic if data != nil && len(data) != calcBitStorageSize(bits, length).
 func NewBitStorage(bits, length int, data []uint64) (b *BitStorage) {
 	if bits == 0 {
 		return nil
@@ -38,7 +38,7 @@ func NewBitStorage(bits, length int, data []uint64) (b *BitStorage) {
 		length:        length,
 		valuesPerLong: 64 / bits,
 	}
-	dataLen := BitStorageSize(bits, length)
+	dataLen := calcBitStorageSize(bits, length)
 	if data != nil {
 		if len(data) != dataLen {
 			panic(newBitStorageErr{ArrlLen: len(data), WantLen: dataLen})
@@ -50,8 +50,8 @@ func NewBitStorage(bits, length int, data []uint64) (b *BitStorage) {
 	return
 }
 
-// BitStorageSize calculate how many uint64 is needed for given bits and length.
+// calcBitStorageSize calculate how many uint64 is needed for given bits and length.
-func BitStorageSize(bits, length int) (size int) {
+func calcBitStorageSize(bits, length int) (size int) {
 	if bits == 0 {
 		return 0
 	}

save/palette.go

@@ -11,10 +11,67 @@ type BlockState interface {
 }
 
 type PaletteContainer struct {
-	maps   blockMaps
+	bits    int
-	config func(p *PaletteContainer, bits byte)
+	maps    IdMaps
-	palette
+	config  func(maps IdMaps, bits int) palette
-	BitStorage
+	palette palette
+	data    *BitStorage
+}
+
+func NewStatesPaletteContainer(maps IdMaps, length int) *PaletteContainer {
+	return &PaletteContainer{
+		bits:    0,
+		maps:    maps,
+		config:  createStatesPalette,
+		palette: createStatesPalette(maps, 0),
+		data:    NewBitStorage(0, length, nil),
+	}
+}
+
+func NewBiomesPaletteContainer(maps IdMaps, length int) *PaletteContainer {
+	return &PaletteContainer{
+		bits:    0,
+		maps:    maps,
+		config:  createBiomesPalette,
+		palette: createBiomesPalette(maps, 0),
+		data:    NewBitStorage(0, length, nil),
+	}
+}
+
+func (p *PaletteContainer) Get(i int) BlockState {
+	return p.palette.value(p.data.Get(i))
+}
+
+func (p *PaletteContainer) Set(i int, v BlockState) {
+	if vv, ok := p.palette.id(v); ok {
+		p.data.Set(i, vv)
+	} else {
+		// resize
+		oldLen := p.data.Len()
+		newPalette := PaletteContainer{
+			bits:    vv,
+			maps:    p.maps,
+			config:  p.config,
+			palette: p.config(p.maps, vv),
+			data:    NewBitStorage(vv, oldLen+1, nil),
+		}
+		// copy
+		for i := 0; i < oldLen; i++ {
+			raw := p.palette.value(i)
+			if vv, ok := newPalette.palette.id(raw); !ok {
+				panic("not reachable")
+			} else {
+				newPalette.data.Set(i, vv)
+			}
+		}
+
+		if vv, ok := newPalette.palette.id(v); !ok {
+			panic("not reachable")
+		} else {
+			newPalette.data.Set(oldLen, vv)
+		}
+		*p = newPalette
+	}
 }
 
 func (p *PaletteContainer) ReadFrom(r io.Reader) (n int64, err error) {
@@ -23,7 +80,7 @@ func (p *PaletteContainer) ReadFrom(r io.Reader) (n int64, err error) {
 	if err != nil {
 		return
 	}
-	p.config(p, byte(bits))
+	p.palette = p.config(p.maps, int(bits))
 
 	nn, err := p.palette.ReadFrom(r)
 	n += nn
@@ -31,7 +88,7 @@ func (p *PaletteContainer) ReadFrom(r io.Reader) (n int64, err error) {
 		return n, err
 	}
 
-	nn, err = p.BitStorage.ReadFrom(r)
+	nn, err = p.data.ReadFrom(r)
 	n += nn
 	if err != nil {
 		return n, err
@@ -39,51 +96,46 @@ func (p *PaletteContainer) ReadFrom(r io.Reader) (n int64, err error) {
 	return n, nil
 }
 
-func createStatesPalette(p *PaletteContainer, bits byte) {
+func createStatesPalette(maps IdMaps, bits int) palette {
 	switch bits {
 	case 0:
-		p.palette = &singleValuePalette{
+		return &singleValuePalette{
-			onResize: nil,
+			maps: maps,
-			maps:     p.maps,
+			v:    nil,
-			v:        nil,
 		}
 	case 1, 2, 3, 4:
-		p.palette = &linearPalette{
+		return &linearPalette{
-			onResize: nil,
+			maps: maps,
-			maps:     p.maps,
+			bits: 4,
-			bits:     4,
 		}
 	case 5, 6, 7, 8:
 		// TODO: HashMapPalette
-		p.palette = &linearPalette{
+		return &linearPalette{
-			onResize: nil,
+			maps: maps,
-			maps:     p.maps,
+			bits: bits,
-			bits:     4,
 		}
 	default:
-		p.palette = &globalPalette{
+		return &globalPalette{
-			maps: p.maps,
+			maps: maps,
 		}
 	}
 }
 
-func createBiomesPalette(p *PaletteContainer, bits byte) {
+func createBiomesPalette(maps IdMaps, bits int) palette {
 	switch bits {
 	case 0:
-		p.palette = &singleValuePalette{
+		return &singleValuePalette{
-			onResize: nil,
+			maps: maps,
-			maps:     p.maps,
+			v:    nil,
-			v:        nil,
 		}
 	case 1, 2, 3:
-		p.palette = &linearPalette{
+		return &linearPalette{
-			onResize: nil,
+			maps: maps,
-			maps:     p.maps,
+			bits: bits,
-			bits:     4,
 		}
 	default:
-		p.palette = &globalPalette{
+		return &globalPalette{
-			maps: p.maps,
+			maps: maps,
 		}
 	}
 }
@@ -92,38 +144,37 @@ func (p *PaletteContainer) WriteTo(w io.Writer) (n int64, err error) {
 	return pk.Tuple{
 		pk.UnsignedByte(p.bits),
 		p.palette,
-		p.BitStorage,
+		p.data,
 	}.WriteTo(w)
 }
 
 type palette interface {
 	pk.FieldEncoder
 	pk.FieldDecoder
-	id(v BlockState) int
+	id(v BlockState) (int, bool)
 	value(i int) BlockState
 }
 
-type blockMaps interface {
+type IdMaps interface {
 	getID(state BlockState) (id int)
 	getValue(id int) (state BlockState)
 }
 
 type singleValuePalette struct {
-	onResize func(n int, v BlockState) int
+	maps IdMaps
-	maps     blockMaps
+	v    BlockState
-	v        BlockState
 }
 
-func (s *singleValuePalette) id(v BlockState) int {
+func (s *singleValuePalette) id(v BlockState) (int, bool) {
 	if s.v == nil {
 		s.v = v
-		return 0
+		return 0, true
 	}
 	if s.v == v {
-		return 0
+		return 0, true
 	}
 	// We have 2 values now. At least 1 bit is required.
-	return s.onResize(1, v)
+	return 1, false
 }
 
 func (s *singleValuePalette) value(i int) BlockState {
@@ -148,23 +199,22 @@ func (s *singleValuePalette) WriteTo(w io.Writer) (n int64, err error) {
 }
 
 type linearPalette struct {
-	onResize func(n int, v BlockState) int
+	maps   IdMaps
-	maps     blockMaps
+	values []BlockState
-	values   []BlockState
+	bits   int
-	bits     int
 }
 
-func (l *linearPalette) id(v BlockState) int {
+func (l *linearPalette) id(v BlockState) (int, bool) {
 	for i, t := range l.values {
 		if t == v {
-			return i
+			return i, true
 		}
 	}
 	if cap(l.values)-len(l.values) > 0 {
 		l.values = append(l.values, v)
-		return len(l.values) - 1
+		return len(l.values) - 1, true
 	}
-	return l.onResize(l.bits+1, v)
+	return l.bits + 1, false
 }
 
 func (l *linearPalette) value(i int) BlockState {
@@ -205,11 +255,11 @@ func (l *linearPalette) WriteTo(w io.Writer) (n int64, err error) {
 }
 
 type globalPalette struct {
-	maps blockMaps
+	maps IdMaps
 }
 
-func (g *globalPalette) id(v BlockState) int {
+func (g *globalPalette) id(v BlockState) (int, bool) {
-	return g.maps.getID(v)
+	return g.maps.getID(v), true
 }
 
 func (g *globalPalette) value(i int) BlockState {

server/dimension.go

@@ -6,6 +6,7 @@ import (
 	pk "github.com/Tnze/go-mc/net/packet"
 	"github.com/Tnze/go-mc/save"
 	"io"
+	"math/bits"
 	"sync"
 )
 
@@ -20,33 +21,74 @@ type DimInfo struct {
 	HashedSeed uint64
 }
 
-type SimpleDim struct {
+type ChunkPos struct{ X, Z int }
-	Columns map[struct{ X, Z int }]*struct {
+type Chunk struct {
-		sync.Mutex
+	sync.Mutex
+	sections   []Section
+	HeightMaps *save.BitStorage
+}
+
+type Section struct {
+	blockCount int16
+	States     *save.PaletteContainer
+	Biomes     *save.PaletteContainer
+}
+
+func (s *Section) WriteTo(w io.Writer) (int64, error) {
+	return pk.Tuple{
+		pk.Short(s.blockCount),
+		s.States,
+		s.Biomes,
+	}.WriteTo(w)
+}
+
+func (s *Section) ReadFrom(r io.Reader) (int64, error) {
+	return pk.Tuple{
+		pk.Short(s.blockCount),
+		s.States,
+		s.Biomes,
+	}.ReadFrom(r)
+}
+
+func EmptyChunk(secs int) *Chunk {
+	sections := make([]Section, secs)
+	for i := range sections {
+		sections[i] = Section{
+			blockCount: 0,
+			States:     save.NewStatesPaletteContainer(nil, 16*16*16),
+			Biomes:     save.NewBiomesPaletteContainer(nil, 4*4*4),
+		}
+	}
+	return &Chunk{
+		sections:   sections,
+		HeightMaps: save.NewBitStorage(bits.Len(uint(secs)*16), 16*16, nil),
 	}
 }
 
-type chunkData struct {
+func (c *Chunk) WriteTo(w io.Writer) (int64, error) {
-	HeightMaps save.BitStorage
+	data, err := c.Data()
-	BlockState save.BitStorage
+	if err != nil {
-	Biomes     save.BitStorage
+		return 0, err
-}
+	}
-
-func (c *chunkData) WriteTo(w io.Writer) (int64, error) {
 	return pk.Tuple{
 		// Heightmaps
 		pk.NBT(struct {
 			MotionBlocking []uint64 `nbt:"MOTION_BLOCKING"`
 		}{c.HeightMaps.Raw()}),
-		pk.ByteArray(c.Data()), // TODO: Chunk Data
+		pk.ByteArray(data),
-		pk.VarInt(0),           // TODO: Block Entity
+		pk.VarInt(0), // TODO: Block Entity
 	}.WriteTo(w)
 }
 
-func (c *chunkData) Data() []byte {
+func (c *Chunk) Data() ([]byte, error) {
 	var buff bytes.Buffer
-	_, _ = pk.Short(0).WriteTo(&buff)
+	for _, section := range c.sections {
-	return buff.Bytes()
+		_, err := section.WriteTo(&buff)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return buff.Bytes(), nil
 }
 
 type lightData struct {
@@ -76,13 +118,36 @@ func (l *lightData) WriteTo(w io.Writer) (int64, error) {
 	}.WriteTo(w)
 }
 
+type SimpleDim struct {
+	numOfSection int
+	Columns      map[ChunkPos]*Chunk
+}
+
+func NewSimpleDim(secs int) *SimpleDim {
+	return &SimpleDim{
+		numOfSection: secs,
+		Columns:      make(map[ChunkPos]*Chunk),
+	}
+}
+
+func (s *SimpleDim) LoadChunk(pos ChunkPos, c *Chunk) {
+	s.Columns[pos] = c
+}
+
+func (s *SimpleDim) Info() DimInfo {
+	return DimInfo{
+		Name:       "minecraft:overworld",
+		HashedSeed: 0,
+	}
+}
+
 func (s *SimpleDim) PlayerJoin(p *Player) {
 	for pos, column := range s.Columns {
 		column.Lock()
 		packet := pk.Marshal(
 			packetid.ClientboundLevelChunkWithLight,
 			pk.Int(pos.X), pk.Int(pos.Z),
-			&chunkData{},
+			column,
 			&lightData{
 				SkyLightMask:   make(pk.BitSet, (16*16*16-1)>>6+1),
 				BlockLightMask: make(pk.BitSet, (16*16*16-1)>>6+1),
@@ -97,6 +162,18 @@ func (s *SimpleDim) PlayerJoin(p *Player) {
 			return
 		}
 	}
+
+	err := p.WritePacket(Packet757(pk.Marshal(
+		packetid.ClientboundPlayerPosition,
+		pk.Double(0), pk.Double(0), pk.Double(0),
+		pk.Float(0), pk.Float(0),
+		pk.Byte(0),
+		pk.VarInt(0),
+		pk.Boolean(true),
+	)))
+	if err != nil {
+		return
+	}
 }
 
 func (s *SimpleDim) PlayerQuit(p *Player) {

server/gameplay.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	_ "embed"
+	"github.com/Tnze/go-mc/chat"
 	"github.com/Tnze/go-mc/nbt"
 	"sync/atomic"
 
@@ -23,6 +24,7 @@ type GamePlay interface {
 type Game struct {
 	eid int32
 	Dim Dimension
+	*PlayerList
 }
 
 //go:embed DimensionCodec.snbt
@@ -32,6 +34,18 @@ var dimensionCodecSNBT string
 var dimensionSNBT string
 
 func (g *Game) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net.Conn) {
+	remove := g.PlayerList.TryInsert(PlayerSample{
+		Name: name,
+		ID:   id,
+	})
+	if remove == nil {
+		_ = conn.WritePacket(pk.Marshal(
+			packetid.ClientboundDisconnect,
+			chat.TranslateMsg("multiplayer.disconnect.server_full"),
+		))
+		return
+	}
+	defer remove()
 	p := &Player{
 		Conn:     conn,
 		EntityID: g.newEID(),
@@ -61,6 +75,21 @@ func (g *Game) AcceptPlayer(name string, id uuid.UUID, protocol int32, conn *net
 		return
 	}
 	g.Dim.PlayerJoin(p)
+	defer g.Dim.PlayerQuit(p)
+
+	var packet pk.Packet
+	for {
+		err := p.ReadPacket(&packet)
+		if err != nil {
+			return
+		}
+		for _, ph := range p.handlers[packet.ID] {
+			err = ph(p, Packet757(packet))
+		}
+		if err != nil {
+			return
+		}
+	}
 }
 
 func (g *Game) newEID() int32 {

server/player.go

@@ -9,6 +9,7 @@ type Player struct {
 	*net.Conn
 	EntityID int32
 	Gamemode byte
+	handlers map[int32][]packetHandlerFunc
 }
 
 // Packet757 is a packet in protocol 757.
@@ -19,3 +20,17 @@ type Packet757 pk.Packet
 func (p *Player) WritePacket(packet Packet757) error {
 	return p.Conn.WritePacket(pk.Packet(packet))
 }
+
+type PacketHandler struct {
+	ID int32
+	F  packetHandlerFunc
+}
+
+type packetHandlerFunc func(player *Player, packet Packet757) error
+
+func (p *Player) Add(ph PacketHandler) {
+	if p.handlers == nil {
+		p.handlers = make(map[int32][]packetHandlerFunc)
+	}
+	p.handlers[ph.ID] = append(p.handlers[ph.ID], ph.F)
+}