forked from Tnze/go-mc
-
Notifications
You must be signed in to change notification settings - Fork 0
/
chunk.go
128 lines (113 loc) · 2.87 KB
/
chunk.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
// Package ptypes implements encoding and decoding for high-level packets.
package ptypes
import (
"bytes"
"fmt"
"github.com/Tnze/go-mc/bot/world/entity"
"github.com/Tnze/go-mc/nbt"
pk "github.com/Tnze/go-mc/net/packet"
)
// ChunkData is a clientbound packet which describes a chunk.
type ChunkData struct {
X, Z pk.Int
FullChunk pk.Boolean
PrimaryBitMask pk.VarInt
Heightmaps struct{}
Biomes biomesData
Data chunkData
BlockEntities blockEntities
}
func (p *ChunkData) Decode(pkt pk.Packet) error {
r := bytes.NewReader(pkt.Data)
if err := p.X.Decode(r); err != nil {
return fmt.Errorf("X: %v", err)
}
if err := p.Z.Decode(r); err != nil {
return fmt.Errorf("Z: %v", err)
}
if err := p.FullChunk.Decode(r); err != nil {
return fmt.Errorf("full chunk: %v", err)
}
if err := p.PrimaryBitMask.Decode(r); err != nil {
return fmt.Errorf("bit mask: %v", err)
}
if err := (pk.NBT{V: &p.Heightmaps}).Decode(r); err != nil {
return fmt.Errorf("heightmaps: %v", err)
}
// Biome data is only present for full chunks.
if p.FullChunk {
if err := p.Biomes.Decode(r); err != nil {
return fmt.Errorf("heightmaps: %v", err)
}
}
if err := p.Data.Decode(r); err != nil {
return fmt.Errorf("data: %v", err)
}
if err := p.BlockEntities.Decode(r); err != nil {
return fmt.Errorf("block entities: %v", err)
}
return nil
}
type biomesData struct {
data []pk.VarInt
}
func (b *biomesData) Decode(r pk.DecodeReader) error {
var nobd pk.VarInt // Number of Biome Datums
if err := nobd.Decode(r); err != nil {
return err
}
b.data = make([]pk.VarInt, nobd)
for i := 0; i < int(nobd); i++ {
var d pk.VarInt
if err := d.Decode(r); err != nil {
return err
}
b.data[i] = d
}
return nil
}
type chunkData []byte
type blockEntities []entity.BlockEntity
// Decode implement net.packet.FieldDecoder
func (c *chunkData) Decode(r pk.DecodeReader) error {
var sz pk.VarInt
if err := sz.Decode(r); err != nil {
return err
}
*c = make([]byte, sz)
if _, err := r.Read(*c); err != nil {
return err
}
return nil
}
// Decode implement net.packet.FieldDecoder
func (b *blockEntities) Decode(r pk.DecodeReader) error {
var sz pk.VarInt // Number of BlockEntities
if err := sz.Decode(r); err != nil {
return err
}
*b = make(blockEntities, sz)
decoder := nbt.NewDecoder(r)
for i := 0; i < int(sz); i++ {
if err := decoder.Decode(&(*b)[i]); err != nil {
return err
}
}
return nil
}
// TileEntityData describes a change to a tile entity.
type TileEntityData struct {
Pos pk.Position
Action pk.UnsignedByte
Data entity.BlockEntity
}
func (p *TileEntityData) Decode(pkt pk.Packet) error {
r := bytes.NewReader(pkt.Data)
if err := p.Pos.Decode(r); err != nil {
return fmt.Errorf("position: %v", err)
}
if err := p.Action.Decode(r); err != nil {
return fmt.Errorf("action: %v", err)
}
return nbt.NewDecoder(r).Decode(&p.Data)
}