falloutBot/go-mc
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

PaletteContainer

Browse Source
This commit is contained in:
Tnze
2021-12-19 13:37:45 +08:00
parent 58f7fe336d
commit a4c4ffd6be
8 changed files with 250 additions and 2273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
examples/frameworkServer/Dimension.snbt
View File

@ -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
}

2093
examples/frameworkServer/DimensionCodec.snbt
View File

File diff suppressed because it is too large Load Diff

96
examples/frameworkServer/main.go
View File

@ -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{
playerList: playerList,
}
defaultDimension := server.NewSimpleDim(16)
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
))
}

8
save/bitstorage.go
View File

@ -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.
func BitStorageSize(bits, length int) (size int) {
// calcBitStorageSize calculate how many uint64 is needed for given bits and length.
func calcBitStorageSize(bits, length int) (size int) {
if bits == 0 {
return 0
}

156
save/palette.go
View File

@ -11,10 +11,67 @@ type BlockState interface {
}
type PaletteContainer struct {
maps blockMaps
config func(p *PaletteContainer, bits byte)
palette
BitStorage
bits int
maps IdMaps
config func(maps IdMaps, bits int) palette
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{
onResize: nil,
maps: p.maps,
v: nil,
return &singleValuePalette{
maps: maps,
v: nil,
}
case 1, 2, 3, 4:
p.palette = &linearPalette{
onResize: nil,
maps: p.maps,
bits: 4,
return &linearPalette{
maps: maps,
bits: 4,
}
case 5, 6, 7, 8:
// TODO: HashMapPalette
p.palette = &linearPalette{
onResize: nil,
maps: p.maps,
bits: 4,
return &linearPalette{
maps: maps,
bits: bits,
}
default:
p.palette = &globalPalette{
maps: p.maps,
return &globalPalette{
maps: maps,
}
}
}
func createBiomesPalette(p *PaletteContainer, bits byte) {
func createBiomesPalette(maps IdMaps, bits int) palette {
switch bits {
case 0:
p.palette = &singleValuePalette{
onResize: nil,
maps: p.maps,
v: nil,
return &singleValuePalette{
maps: maps,
v: nil,
}
case 1, 2, 3:
p.palette = &linearPalette{
onResize: nil,
maps: p.maps,
bits: 4,
return &linearPalette{
maps: maps,
bits: bits,
}
default:
p.palette = &globalPalette{
maps: p.maps,
return &globalPalette{
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 blockMaps
v BlockState
maps IdMaps
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 blockMaps
values []BlockState
bits int
maps IdMaps
values []BlockState
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 {
return g.maps.getID(v)
func (g *globalPalette) id(v BlockState) (int, bool) {
return g.maps.getID(v), true
}
func (g *globalPalette) value(i int) BlockState {

109
server/dimension.go
View File

@ -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 {
Columns map[struct{ X, Z int }]*struct {
sync.Mutex
type ChunkPos struct{ X, Z int }
type Chunk struct {
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 {
HeightMaps save.BitStorage
BlockState save.BitStorage
Biomes save.BitStorage
}
func (c *chunkData) WriteTo(w io.Writer) (int64, error) {
func (c *Chunk) WriteTo(w io.Writer) (int64, error) {
data, err := c.Data()
if err != nil {
return 0, err
}
return pk.Tuple{
// Heightmaps
pk.NBT(struct {
MotionBlocking []uint64 `nbt:"MOTION_BLOCKING"`
}{c.HeightMaps.Raw()}),
pk.ByteArray(c.Data()), // TODO: Chunk Data
pk.VarInt(0), // TODO: Block Entity
pk.ByteArray(data),
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)
return buff.Bytes()
for _, section := range c.sections {
_, 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) {

29
server/gameplay.go
View File

@ -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 {

15
server/player.go
View File

@ -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)
}