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

Fix other code for compatible with new go-mc/net packet

Browse Source
This commit is contained in:
Tnze
2021-02-25 20:22:06 +08:00
parent 27a30efe7b
commit f8b3501b60
16 changed files with 461 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
bot/ingame.go
View File

@ -294,22 +294,16 @@ func handleEntityStatusPacket(c *Client, p pk.Packet) error {
}
func handleDestroyEntitiesPacket(c *Client, p pk.Packet) error {
var (
count pk.VarInt
r = bytes.NewReader(p.Data)
)
if err := count.Decode(r); err != nil {
var count pk.VarInt
var data = pk.Ary{
Len: &count,
Ary: []pk.VarInt{},
}
if err := p.Scan(&count, &data); err != nil {
return err
}
entities := make([]pk.VarInt, int(count))
for i := 0; i < int(count); i++ {
if err := entities[i].Decode(r); err != nil {
return err
}
}
return c.Wd.OnEntityDestroy(entities)
return c.Wd.OnEntityDestroy(data.Ary.([]pk.VarInt))
}
func handleSoundEffect(c *Client, p pk.Packet) error {
@ -378,34 +372,24 @@ func handleMultiBlockChangePacket(c *Client, p pk.Packet) error {
if !c.settings.ReceiveMap {
return nil
}
r := bytes.NewReader(p.Data)
var (
loc pk.Long
dontTrustEdges pk.Boolean
sz pk.VarInt
)
if err := loc.Decode(r); err != nil {
return fmt.Errorf("packed location: %v", err)
}
if err := dontTrustEdges.Decode(r); err != nil {
return fmt.Errorf("unknown 1: %v", err)
}
if err := sz.Decode(r); err != nil {
return fmt.Errorf("array size: %v", err)
}
packedBlocks := make([]pk.VarLong, int(sz))
for i := 0; i < int(sz); i++ {
if err := packedBlocks[i].Decode(r); err != nil {
return fmt.Errorf("block[%d]: %v", i, err)
packedBlocks = pk.Ary{
Len: &sz,
Ary: []pk.VarLong{},
}
)
err := p.Scan(&loc, &dontTrustEdges, &sz, &packedBlocks)
if err != nil {
return err
}
x, z, y := int((loc>>42)&((1<<22)-1)),
int((loc>>20)&((1<<22)-1)),
int(loc&((1<<20)-1))
x := int((loc >> 42) & ((1 << 22) - 1))
y := int((loc >> 20) & ((1 << 22) - 1))
z := int(loc & ((1 << 20) - 1))
// Apply transform into negative (these numbers are signed)
if x >= 1<<21 {
@ -415,7 +399,7 @@ func handleMultiBlockChangePacket(c *Client, p pk.Packet) error {
z -= 1 << 22
}
c.Wd.MultiBlockUpdate(world.ChunkLoc{X: x, Z: z}, y, packedBlocks)
c.Wd.MultiBlockUpdate(world.ChunkLoc{X: x, Z: z}, y, packedBlocks.Ary.([]pk.VarLong))
return nil
}
@ -520,14 +504,14 @@ func handlePluginPacket(c *Client, p pk.Packet) error {
switch msg.Channel {
case "minecraft:brand":
var brandRaw pk.String
if err := brandRaw.Decode(bytes.NewReader(msg.Data)); err != nil {
if _, err := brandRaw.ReadFrom(bytes.NewReader(msg.Data)); err != nil {
return err
}
c.ServInfo.Brand = string(brandRaw)
}
if c.Events.PluginMessage != nil {
return c.Events.PluginMessage(string(msg.Channel), []byte(msg.Data))
return c.Events.PluginMessage(string(msg.Channel), msg.Data)
}
return nil
}
@ -622,7 +606,7 @@ func handleChunkDataPacket(c *Client, p pk.Packet) error {
}
var pkt ptypes.ChunkData
if err := pkt.Decode(p); err != nil {
if _, err := pkt.ReadFrom(bytes.NewReader(p.Data)); err != nil {
return err
}
@ -641,7 +625,7 @@ func handleChunkDataPacket(c *Client, p pk.Packet) error {
func handleTileEntityDataPacket(c *Client, p pk.Packet) error {
var pkt ptypes.TileEntityData
if err := pkt.Decode(p); err != nil {
if _, err := pkt.ReadFrom(bytes.NewReader(p.Data)); err != nil {
return err
}
return c.Wd.TileEntityUpdate(pkt)
@ -712,7 +696,7 @@ func handleKeepAlivePacket(c *Client, p pk.Packet) error {
func handleWindowItemsPacket(c *Client, p pk.Packet) error {
var pkt ptypes.WindowItems
if err := pkt.Decode(p); err != nil {
if _, err := pkt.ReadFrom(bytes.NewReader(p.Data)); err != nil {
return err
}

49
bot/login.go
View File

@ -62,34 +62,12 @@ type encryptionRequest struct {
VerifyToken []byte
}
func (e *encryptionRequest) Decode(r pk.DecodeReader) error {
var serverID pk.String
if err := serverID.Decode(r); err != nil {
return err
}
var publicKeyLength, verifyTokenLength pk.VarInt
if err := publicKeyLength.Decode(r); err != nil {
return err
}
publicKey, err := pk.ReadNBytes(r, int(publicKeyLength))
if err != nil {
return err
}
if err := verifyTokenLength.Decode(r); err != nil {
return err
}
verifyToken, err := pk.ReadNBytes(r, int(verifyTokenLength))
if err != nil {
return err
}
e.ServerID = string(serverID)
e.PublicKey = publicKey
e.VerifyToken = verifyToken
return nil
func (e *encryptionRequest) ReadFrom(r io.Reader) (int64, error) {
return pk.Tuple{
(*pk.String)(&e.ServerID),
(*pk.ByteArray)(&e.PublicKey),
(*pk.ByteArray)(&e.VerifyToken),
}.ReadFrom(r)
}
// authDigest computes a special SHA-1 digest required for Minecraft web
@ -216,14 +194,9 @@ func genEncryptionKeyResponse(shareSecret, publicKey, verifyToken []byte) (erp p
err = fmt.Errorf("encryption verfy tokenfail: %v", err)
return
}
var data []byte
data = append(data, pk.VarInt(int32(len(cryptPK))).Encode()...)
data = append(data, cryptPK...)
data = append(data, pk.VarInt(int32(len(verifyT))).Encode()...)
data = append(data, verifyT...)
erp = pk.Packet{
ID: 0x01,
Data: data,
}
return
return pk.Marshal(
0x01,
pk.ByteArray(cryptPK),
pk.ByteArray(verifyT),
), nil
}

15
bot/world/chunk.go
View File

@ -3,6 +3,7 @@ package world
import (
"bytes"
"fmt"
"io"
"math"
"github.com/Tnze/go-mc/data/block"
@ -41,13 +42,13 @@ func perBits(bpb byte) uint {
}
}
func readSection(data pk.DecodeReader) (s Section, err error) {
func readSection(data io.Reader) (s Section, err error) {
var nonAirBlockCount pk.Short
if err := nonAirBlockCount.Decode(data); err != nil {
if _, err := nonAirBlockCount.ReadFrom(data); err != nil {
return nil, fmt.Errorf("block count: %w", err)
}
var bpb pk.UnsignedByte
if err := bpb.Decode(data); err != nil {
if _, err := bpb.ReadFrom(data); err != nil {
return nil, fmt.Errorf("bits per block: %w", err)
}
// If bpb values greater than or equal to 9, use directSection.
@ -57,14 +58,14 @@ func readSection(data pk.DecodeReader) (s Section, err error) {
if bpb <= maxPaletteBits {
// read palettes
var length pk.VarInt
if err := length.Decode(data); err != nil {
if _, err := length.ReadFrom(data); err != nil {
return nil, fmt.Errorf("palette length: %w", err)
}
palettes = make([]BlockStatus, length)
palettesIndex = make(map[BlockStatus]int, length)
for i := 0; i < int(length); i++ {
var v pk.VarInt
if err := v.Decode(data); err != nil {
if _, err := v.ReadFrom(data); err != nil {
return nil, fmt.Errorf("read palettes[%d] error: %w", i, err)
}
palettes[i] = BlockStatus(v)
@ -74,7 +75,7 @@ func readSection(data pk.DecodeReader) (s Section, err error) {
// read data array
var dataLen pk.VarInt
if err := dataLen.Decode(data); err != nil {
if _, err := dataLen.ReadFrom(data); err != nil {
return nil, fmt.Errorf("read data array length error: %w", err)
}
if int(dataLen) < 16*16*16*int(bpb)/64 {
@ -83,7 +84,7 @@ func readSection(data pk.DecodeReader) (s Section, err error) {
dataArray := make([]uint64, dataLen)
for i := 0; i < int(dataLen); i++ {
var v pk.Long
if err := v.Decode(data); err != nil {
if _, err := v.ReadFrom(data); err != nil {
return nil, fmt.Errorf("read dataArray[%d] error: %w", i, err)
}
dataArray[i] = uint64(v)

78
bot/world/entity/entity.go
View File

@ -1,11 +1,10 @@
package entity
import (
"bytes"
"io"
"github.com/Tnze/go-mc/data/entity"
item "github.com/Tnze/go-mc/data/item"
"github.com/Tnze/go-mc/nbt"
pk "github.com/Tnze/go-mc/net/packet"
"github.com/google/uuid"
)
@ -49,53 +48,48 @@ type Slot struct {
Present bool
ItemID item.ID
Count int8
NBT interface{}
NBT pk.NBT
}
type SlotNBT struct {
data interface{}
}
//Decode implement packet.FieldDecoder interface
func (s *Slot) Decode(r pk.DecodeReader) error {
if err := (*pk.Boolean)(&s.Present).Decode(r); err != nil {
return err
func (s *Slot) ReadFrom(r io.Reader) (int64, error) {
var itemID pk.VarInt
n, err := pk.Tuple{
(*pk.Boolean)(&s.Present),
pk.Opt{
Has: (*pk.Boolean)(&s.Present),
Field: pk.Tuple{
&itemID,
(*pk.Byte)(&s.Count),
&s.NBT,
},
},
}.ReadFrom(r)
if err != nil {
return n, err
}
if s.Present {
var itemID pk.VarInt
if err := itemID.Decode(r); err != nil {
return err
}
s.ItemID = item.ID(itemID)
if err := (*pk.Byte)(&s.Count).Decode(r); err != nil {
return err
}
if err := nbt.NewDecoder(r).Decode(&s.NBT); err != nil {
return err
}
}
return nil
s.ItemID = item.ID(itemID)
return n, nil
}
func (s Slot) Encode() []byte {
if !s.Present {
return pk.Boolean(false).Encode()
}
var b bytes.Buffer
b.Write(pk.Boolean(true).Encode())
b.Write(pk.VarInt(s.ItemID).Encode())
b.Write(pk.Byte(s.Count).Encode())
if s.NBT != nil {
if err := nbt.NewEncoder(&b).Encode(s.NBT); err != nil {
panic(err)
}
} else {
if _, err := b.Write([]byte{nbt.TagEnd}); err != nil {
panic(err)
}
}
return b.Bytes()
func (s Slot) WriteTo(w io.Writer) (int64, error) {
return pk.Tuple{
pk.Boolean(s.Present),
pk.Opt{
Has: (*pk.Boolean)(&s.Present),
Field: pk.Tuple{
pk.VarInt(s.ItemID),
pk.Byte(s.Count),
s.NBT,
},
},
}.WriteTo(w)
}
func (s Slot) String() string {
return item.ByID[item.ID(s.ItemID)].DisplayName
return item.ByID[s.ItemID].DisplayName
}