init
This commit is contained in:
JunDao
141
net/packet/packet.go
Normal file
141
net/packet/packet.go
Normal file
@ -0,0 +1,141 @@
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"fmt"
|
||||
"io"
|
||||
)
|
||||
|
||||
// Packet define a net data package
|
||||
type Packet struct {
|
||||
ID byte
|
||||
Data []byte
|
||||
}
|
||||
|
||||
//Marshal generate Packet with the ID and Fields
|
||||
func Marshal(ID byte, fields ...FieldEncoder) (pk Packet) {
|
||||
pk.ID = ID
|
||||
|
||||
for _, v := range fields {
|
||||
pk.Data = append(pk.Data, v.Encode()...)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
//Scan decode the packet and fill data into fields
|
||||
func (p Packet) Scan(fields ...FieldDecoder) error {
|
||||
r := bytes.NewReader(p.Data)
|
||||
for _, v := range fields {
|
||||
err := v.Decode(r)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Pack 打包一个数据包
|
||||
func (p *Packet) Pack(threshold int) (pack []byte) {
|
||||
data := []byte{p.ID} //data
|
||||
data = append(data, p.Data...) //data
|
||||
|
||||
if threshold > 0 { //是否启用了压缩
|
||||
if len(data) > threshold { //是否需要压缩
|
||||
Len := len(data)
|
||||
VarLen := VarInt(Len).Encode()
|
||||
data = Compress(data)
|
||||
|
||||
pack = append(pack, VarInt(len(VarLen)+len(data)).Encode()...)
|
||||
pack = append(pack, VarLen...)
|
||||
pack = append(pack, data...)
|
||||
} else {
|
||||
pack = append(pack, VarInt(int32(len(data)+1)).Encode()...)
|
||||
pack = append(pack, 0x00)
|
||||
pack = append(pack, data...)
|
||||
}
|
||||
} else {
|
||||
pack = append(pack, VarInt(int32(len(data))).Encode()...) //len
|
||||
pack = append(pack, data...)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// RecvPacket recive a packet from server
|
||||
func RecvPacket(r io.ByteReader, useZlib bool) (*Packet, error) {
|
||||
var len int
|
||||
for i := 0; i < 5; i++ { //读数据前的长度标记
|
||||
b, err := r.ReadByte()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read len of packet fail: %v", err)
|
||||
}
|
||||
len |= (int(b&0x7F) << uint(7*i))
|
||||
if b&0x80 == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if len < 1 {
|
||||
return nil, fmt.Errorf("packet length too short")
|
||||
}
|
||||
|
||||
data := make([]byte, len) //读包内容
|
||||
var err error
|
||||
for i := 0; i < len; i++ {
|
||||
data[i], err = r.ReadByte()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read content of packet fail: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
//解压数据
|
||||
if useZlib {
|
||||
return UnCompress(data)
|
||||
}
|
||||
|
||||
return &Packet{
|
||||
ID: data[0],
|
||||
Data: data[1:],
|
||||
}, nil
|
||||
}
|
||||
|
||||
// UnCompress 读取一个压缩的包
|
||||
func UnCompress(data []byte) (*Packet, error) {
|
||||
reader := bytes.NewReader(data)
|
||||
|
||||
var sizeUncompressed VarInt
|
||||
if err := sizeUncompressed.Decode(reader); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
uncompressData := make([]byte, sizeUncompressed)
|
||||
if sizeUncompressed != 0 { // != 0 means compressed, let's decompress
|
||||
r, err := zlib.NewReader(reader)
|
||||
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("decompress fail: %v", err)
|
||||
}
|
||||
_, err = io.ReadFull(r, uncompressData)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("decompress fail: %v", err)
|
||||
}
|
||||
r.Close()
|
||||
} else {
|
||||
uncompressData = data[1:]
|
||||
}
|
||||
return &Packet{
|
||||
ID: uncompressData[0],
|
||||
Data: uncompressData[1:],
|
||||
}, nil
|
||||
}
|
||||
|
||||
// Compress 压缩数据
|
||||
func Compress(data []byte) []byte {
|
||||
var b bytes.Buffer
|
||||
w := zlib.NewWriter(&b)
|
||||
w.Write(data)
|
||||
w.Close()
|
||||
return b.Bytes()
|
||||
}
|
||||
62
net/packet/packet_test.go
Normal file
62
net/packet/packet_test.go
Normal file
@ -0,0 +1,62 @@
|
||||
package packet
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var VarInts = []VarInt{0, 1, 2, 127, 128, 255, 2147483647, -1, -2147483648}
|
||||
|
||||
var PackedVarInts = [][]byte{
|
||||
[]byte{0x00},
|
||||
[]byte{0x01},
|
||||
[]byte{0x02},
|
||||
[]byte{0x7f},
|
||||
[]byte{0x80, 0x01},
|
||||
[]byte{0xff, 0x01},
|
||||
[]byte{0xff, 0xff, 0xff, 0xff, 0x07},
|
||||
[]byte{0xff, 0xff, 0xff, 0xff, 0x0f},
|
||||
[]byte{0x80, 0x80, 0x80, 0x80, 0x08},
|
||||
}
|
||||
|
||||
func TestPackInt(t *testing.T) {
|
||||
for i, v := range VarInts {
|
||||
p := v.Encode()
|
||||
if !bytes.Equal(p, PackedVarInts[i]) {
|
||||
t.Errorf("pack int %d should be \"% x\", get \"% x\"", v, PackedVarInts[i], p)
|
||||
}
|
||||
}
|
||||
}
|
||||
func TestUnpackInt(t *testing.T) {
|
||||
for i, v := range PackedVarInts {
|
||||
var vi VarInt
|
||||
if err := vi.Decode(bytes.NewReader(v)); err != nil {
|
||||
t.Errorf("unpack \"% x\" error: %v", v, err)
|
||||
}
|
||||
if vi != VarInts[i] {
|
||||
t.Errorf("unpack \"% x\" should be %d, get %d", v, VarInts[i], vi)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPositionPack(t *testing.T) {
|
||||
// x (-33554432 to 33554431), y (-2048 to 2047), z (-33554432 to 33554431)
|
||||
|
||||
for x := -33554432; x < 33554432; x += 55443 {
|
||||
for y := -2048; y < 2048; y += 48 {
|
||||
for z := -33554432; z < 33554432; z += 55443 {
|
||||
var (
|
||||
pos1 Position
|
||||
pos2 = Position{x, y, z}
|
||||
)
|
||||
if err := pos1.Decode(bytes.NewReader(pos2.Encode())); err != nil {
|
||||
t.Errorf("Position decode fail: %v", err)
|
||||
}
|
||||
|
||||
if pos1 != pos2 {
|
||||
t.Errorf("cannot pack %v", pos2)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
335
net/packet/types.go
Normal file
335
net/packet/types.go
Normal file
@ -0,0 +1,335 @@
|
||||
package packet
|
||||
|
||||
import (
|
||||
"io"
|
||||
"math"
|
||||
)
|
||||
|
||||
type Field interface {
|
||||
FieldEncoder
|
||||
FieldDecoder
|
||||
}
|
||||
|
||||
type FieldEncoder interface {
|
||||
Encode() []byte
|
||||
}
|
||||
|
||||
type FieldDecoder interface {
|
||||
Decode(r io.ByteReader) error
|
||||
}
|
||||
|
||||
type (
|
||||
//Boolean of True is encoded as 0x01, false as 0x00.
|
||||
Boolean bool
|
||||
//Byte is signed 8-bit integer, two's complement
|
||||
Byte int8
|
||||
//UnsignedByte is unsigned 8-bit integer
|
||||
UnsignedByte uint8
|
||||
//Short is signed 16-bit integer, two's complement
|
||||
Short int16
|
||||
//UnsignedShort is unsigned 16-bit integer
|
||||
UnsignedShort uint16
|
||||
//Int is signed 32-bit integer, two's complement
|
||||
Int int32
|
||||
//Long is signed 64-bit integer, two's complement
|
||||
Long int64
|
||||
//A Float is a single-precision 32-bit IEEE 754 floating point number
|
||||
Float float32
|
||||
//A Double is a double-precision 64-bit IEEE 754 floating point number
|
||||
Double float64
|
||||
//String is sequence of Unicode scalar values
|
||||
String string
|
||||
|
||||
//Chat is encoded as a String with max length of 32767.
|
||||
Chat = String
|
||||
//Identifier is encoded as a String with max length of 32767.
|
||||
Identifier = String
|
||||
|
||||
//VarInt is variable-length data encoding a two's complement signed 32-bit integer
|
||||
VarInt int32
|
||||
//VarLong is variable-length data encoding a two's complement signed 64-bit integer
|
||||
VarLong int64
|
||||
|
||||
//Position x as a 26-bit integer, followed by y as a 12-bit integer, followed by z as a 26-bit integer (all signed, two's complement)
|
||||
Position struct {
|
||||
X, Y, Z int
|
||||
}
|
||||
|
||||
//Angle is rotation angle in steps of 1/256 of a full turn
|
||||
Angle int8
|
||||
|
||||
//UUID encoded as an unsigned 128-bit integer
|
||||
UUID [16]byte
|
||||
)
|
||||
|
||||
//ReadNBytes read N bytes from bytes.Reader
|
||||
func ReadNBytes(r io.ByteReader, n int) (bs []byte, err error) {
|
||||
bs = make([]byte, n)
|
||||
for i := 0; i < n; i++ {
|
||||
bs[i], err = r.ReadByte()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
//Encode a Boolean
|
||||
func (b Boolean) Encode() []byte {
|
||||
if b {
|
||||
return []byte{0x01}
|
||||
}
|
||||
return []byte{0x00}
|
||||
}
|
||||
|
||||
//Decode a Boolean
|
||||
func (b *Boolean) Decode(r io.ByteReader) error {
|
||||
v, err := r.ReadByte()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*b = Boolean(v != 0)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Encode a String
|
||||
func (s String) Encode() (p []byte) {
|
||||
byteString := []byte(s)
|
||||
p = append(p, VarInt(len(byteString)).Encode()...) //len
|
||||
p = append(p, byteString...) //data
|
||||
return
|
||||
}
|
||||
|
||||
//Decode a String
|
||||
func (s *String) Decode(r io.ByteReader) error {
|
||||
var l VarInt //String length
|
||||
if err := l.Decode(r); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
bs, err := ReadNBytes(r, int(l))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*s = String(bs)
|
||||
return nil
|
||||
}
|
||||
|
||||
//Encode a Byte
|
||||
func (b Byte) Encode() []byte {
|
||||
return []byte{byte(b)}
|
||||
}
|
||||
|
||||
//Decode a Byte
|
||||
func (b *Byte) Decode(r io.ByteReader) error {
|
||||
v, err := r.ReadByte()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*b = Byte(v)
|
||||
return nil
|
||||
}
|
||||
|
||||
//Encode a UnsignedByte
|
||||
func (ub UnsignedByte) Encode() []byte {
|
||||
return []byte{byte(ub)}
|
||||
}
|
||||
|
||||
//Decode a UnsignedByte
|
||||
func (ub *UnsignedByte) Decode(r io.ByteReader) error {
|
||||
v, err := r.ReadByte()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*ub = UnsignedByte(v)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Encode a Signed Short
|
||||
func (s Short) Encode() []byte {
|
||||
n := uint16(s)
|
||||
return []byte{
|
||||
byte(n >> 8),
|
||||
byte(n),
|
||||
}
|
||||
}
|
||||
|
||||
//Decode a Short
|
||||
func (s *Short) Decode(r io.ByteReader) error {
|
||||
bs, err := ReadNBytes(r, 2)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*s = Short(int16(bs[0])<<8 | int16(bs[1]))
|
||||
return nil
|
||||
}
|
||||
|
||||
// Encode a Unsigned Short
|
||||
func (us UnsignedShort) Encode() []byte {
|
||||
n := uint16(us)
|
||||
return []byte{
|
||||
byte(n >> 8),
|
||||
byte(n),
|
||||
}
|
||||
}
|
||||
|
||||
//Decode a UnsignedShort
|
||||
func (us *UnsignedShort) Decode(r io.ByteReader) error {
|
||||
bs, err := ReadNBytes(r, 2)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*us = UnsignedShort(int16(bs[0])<<8 | int16(bs[1]))
|
||||
return nil
|
||||
}
|
||||
|
||||
// Encode a Int
|
||||
func (i Int) Encode() []byte {
|
||||
n := uint32(i)
|
||||
return []byte{
|
||||
byte(n >> 24), byte(n >> 16),
|
||||
byte(n >> 8), byte(n),
|
||||
}
|
||||
}
|
||||
|
||||
//Decode a Int
|
||||
func (i *Int) Decode(r io.ByteReader) error {
|
||||
bs, err := ReadNBytes(r, 4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*i = Int(int32(bs[0])<<24 | int32(bs[1])<<16 | int32(bs[2])<<8 | int32(bs[3]))
|
||||
return nil
|
||||
}
|
||||
|
||||
// Encode a Long
|
||||
func (l Long) Encode() []byte {
|
||||
n := uint64(l)
|
||||
return []byte{
|
||||
byte(n >> 56), byte(n >> 48), byte(n >> 40), byte(n >> 32),
|
||||
byte(n >> 24), byte(n >> 16), byte(n >> 8), byte(n),
|
||||
}
|
||||
}
|
||||
|
||||
//Decode a Long
|
||||
func (l *Long) Decode(r io.ByteReader) error {
|
||||
bs, err := ReadNBytes(r, 8)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*l = Long(int64(bs[0])<<56 | int64(bs[1])<<48 | int64(bs[2])<<40 | int64(bs[3])<<32 |
|
||||
int64(bs[4])<<24 | int64(bs[5])<<16 | int64(bs[6])<<8 | int64(bs[7]))
|
||||
return nil
|
||||
}
|
||||
|
||||
//Encode a VarInt
|
||||
func (v VarInt) Encode() (vi []byte) {
|
||||
num := uint32(v)
|
||||
for {
|
||||
b := num & 0x7F
|
||||
num >>= 7
|
||||
if num != 0 {
|
||||
b |= 0x80
|
||||
}
|
||||
vi = append(vi, byte(b))
|
||||
if num == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
//Decode a VarInt
|
||||
func (v *VarInt) Decode(r io.ByteReader) error {
|
||||
var n uint32
|
||||
for i := 0; i < 5; i++ { //读数据前的长度标记
|
||||
sec, err := r.ReadByte()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
n |= (uint32(sec&0x7F) << uint32(7*i))
|
||||
|
||||
if sec&0x80 == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
*v = VarInt(n)
|
||||
return nil
|
||||
}
|
||||
|
||||
//Encode a Position
|
||||
func (p Position) Encode() []byte {
|
||||
b := make([]byte, 8)
|
||||
position := (uint64(p.X&0x3FFFFFF)<<38 | uint64((p.Z&0x3FFFFFF)<<12) | uint64(p.Y&0xFFF))
|
||||
for i := 7; i >= 0; i-- {
|
||||
b[i] = byte(position)
|
||||
position >>= 8
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// Decode a Position
|
||||
func (p *Position) Decode(r io.ByteReader) error {
|
||||
var v Long
|
||||
if err := v.Decode(r); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
x := int(v >> 38)
|
||||
y := int(v & 0xFFF)
|
||||
z := int(v << 26 >> 38)
|
||||
|
||||
//处理负数
|
||||
if x >= 1<<25 {
|
||||
x -= 1 << 26
|
||||
}
|
||||
if y >= 1<<11 {
|
||||
y -= 1 << 12
|
||||
}
|
||||
if z >= 1<<25 {
|
||||
z -= 1 << 26
|
||||
}
|
||||
|
||||
p.X, p.Y, p.Z = x, y, z
|
||||
return nil
|
||||
}
|
||||
|
||||
//Encode a Float
|
||||
func (f Float) Encode() []byte {
|
||||
return Int(math.Float32bits(float32(f))).Encode()
|
||||
}
|
||||
|
||||
// Decode a Float
|
||||
func (f *Float) Decode(r io.ByteReader) error {
|
||||
var v Int
|
||||
if err := v.Decode(r); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*f = Float(math.Float32frombits(uint32(v)))
|
||||
return nil
|
||||
}
|
||||
|
||||
//Encode a Double
|
||||
func (d Double) Encode() []byte {
|
||||
return Long(math.Float64bits(float64(d))).Encode()
|
||||
}
|
||||
|
||||
// Decode a Double
|
||||
func (d *Double) Decode(r io.ByteReader) error {
|
||||
var v Long
|
||||
if err := v.Decode(r); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
*d = Double(math.Float64frombits(uint64(v)))
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user