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

try read ChunkData

Browse Source
This commit is contained in:
JunDao
2019-05-21 00:11:27 +08:00
parent 6be465640f
commit 837bb0b213
7 changed files with 46247 additions and 20499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
bot/client.go
View File

@ -41,8 +41,10 @@ func NewClient() (c *Client) {
c.Name = "Steve" c.Name = "Steve"
c.Delegate = make(chan func() error) c.Delegate = make(chan func() error)
c.Wd.Entities = make(map[int32]entity.Entity) c.Wd = world.World{
c.Wd.Chunks = make(map[world.ChunkLoc]*world.Chunk) Entities: make(map[int32]entity.Entity),
Chunks: make(map[world.ChunkLoc]*world.Chunk),
}
return return
} }

256
bot/ingame.go
View File

@ -432,10 +432,58 @@ func handleChunkDataPacket(c *Client, p pk.Packet) error {
if !c.settings.ReciveMap { if !c.settings.ReciveMap {
return nil return nil
} }
var (
X, Z pk.Int
FullChunk pk.Boolean
PrimaryBitMask pk.VarInt
Heightmaps struct{}
Data chunkData
BlockEntities blockEntities
)
chunk, x, z, err := world.UnpackChunkDataPacket(p, c.Dimension == 0) if err := p.Scan(&X, &Z, &FullChunk, &PrimaryBitMask, pk.NBT{V: &Heightmaps}, &Data, &BlockEntities); err != nil {
c.Wd.Chunks[world.ChunkLoc{x, z}] = chunk
return err return err
}
chunk, err := world.DecodeChunkColumn(bool(FullChunk), int32(PrimaryBitMask), Data)
if err != nil {
return fmt.Errorf("decode chunk column fail: %v", err)
}
c.Wd.LoadChunk(int(X), int(Z), chunk)
return err
}
type chunkData []byte
type blockEntities []blockEntitie
type blockEntitie struct {
}
func (c *chunkData) Decode(r pk.DecodeReader) error {
var Size pk.VarInt
if err := Size.Decode(r); err != nil {
return err
}
*c = make([]byte, Size)
if _, err := r.Read(*c); err != nil {
return err
}
return nil
}
func (b *blockEntities) Decode(r pk.DecodeReader) error {
var NumberofBlockEntities pk.VarInt
if err := NumberofBlockEntities.Decode(r); err != nil {
return err
}
*b = make(blockEntities, NumberofBlockEntities)
decoder := nbt.NewDecoder(r)
for i := 0; i < int(NumberofBlockEntities); i++ {
if err := decoder.Decode(&(*b)[i]); err != nil {
return err
}
}
return nil
} }
// var isSpawn bool // var isSpawn bool
@ -486,111 +534,6 @@ func handlePlayerPositionAndLookPacket(c *Client, p pk.Packet) error {
)) ))
} }
// func handleDeclareRecipesPacket(g *Client, r *bytes.Reader) {
// //Ignore Declare Recipes Packet
// // NumRecipes, index := pk.UnpackVarInt(p.Data)
// // for i := 0; i < int(NumRecipes); i++ {
// // RecipeID, len := pk.UnpackString(p.Data[index:])
// // index += len
// // Type, len := pk.UnpackString(p.Data[index:])
// // index += len
// // switch Type {
// // case "crafting_shapeless":
// // }
// // }
// }
// func handleEntityLookAndRelativeMove(g *Client, r *bytes.Reader) error {
// ID, err := pk.UnpackVarInt(r)
// if err != nil {
// return err
// }
// E := g.wd.Entities[ID]
// if E != nil {
// P, ok := E.(*Player)
// if !ok {
// return nil
// }
// DeltaX, err := pk.UnpackInt16(r)
// if err != nil {
// return err
// }
// DeltaY, err := pk.UnpackInt16(r)
// if err != nil {
// return err
// }
// DeltaZ, err := pk.UnpackInt16(r)
// if err != nil {
// return err
// }
// yaw, err := r.ReadByte()
// if err != nil {
// return err
// }
// pitch, err := r.ReadByte()
// if err != nil {
// return err
// }
// P.Yaw += float32(yaw) * (1.0 / 256)
// P.Pitch += float32(pitch) * (1.0 / 256)
// og, err := r.ReadByte()
// if err != nil {
// return err
// }
// P.OnGround = og != 0x00
// P.X += float64(DeltaX) / 128
// P.Y += float64(DeltaY) / 128
// P.Z += float64(DeltaZ) / 128
// }
// return nil
// }
// func handleEntityHeadLookPacket(g *Client, r *bytes.Reader) {
// }
// func handleEntityRelativeMovePacket(g *Client, r *bytes.Reader) error {
// ID, err := pk.UnpackVarInt(r)
// if err != nil {
// return err
// }
// E := g.wd.Entities[ID]
// if E != nil {
// P, ok := E.(*Player)
// if !ok {
// return nil
// }
// DeltaX, err := pk.UnpackInt16(r)
// if err != nil {
// return err
// }
// DeltaY, err := pk.UnpackInt16(r)
// if err != nil {
// return err
// }
// DeltaZ, err := pk.UnpackInt16(r)
// if err != nil {
// return err
// }
// og, err := r.ReadByte()
// if err != nil {
// return err
// }
// P.OnGround = og != 0x00
// P.X += float64(DeltaX) / 128
// P.Y += float64(DeltaY) / 128
// P.Z += float64(DeltaZ) / 128
// }
// return nil
// }
func handleKeepAlivePacket(c *Client, p pk.Packet) error { func handleKeepAlivePacket(c *Client, p pk.Packet) error {
var KeepAliveID pk.Long var KeepAliveID pk.Long
if err := p.Scan(&KeepAliveID); err != nil { if err := p.Scan(&KeepAliveID); err != nil {
@ -603,54 +546,6 @@ func handleKeepAlivePacket(c *Client, p pk.Packet) error {
)) ))
} }
// func handleEntityPacket(g *Client, r *bytes.Reader) {
// // initialize an entity.
// }
// func handleSpawnPlayerPacket(g *Client, r *bytes.Reader) (err error) {
// np := new(Player)
// np.entityID, err = pk.UnpackVarInt(r)
// if err != nil {
// return
// }
// np.UUID[0], err = pk.UnpackInt64(r)
// if err != nil {
// return
// }
// np.UUID[1], err = pk.UnpackInt64(r)
// if err != nil {
// return
// }
// np.X, err = pk.UnpackDouble(r)
// if err != nil {
// return
// }
// np.Y, err = pk.UnpackDouble(r)
// if err != nil {
// return
// }
// np.Z, err = pk.UnpackDouble(r)
// if err != nil {
// return
// }
// yaw, err := r.ReadByte()
// if err != nil {
// return err
// }
// pitch, err := r.ReadByte()
// if err != nil {
// return err
// }
// np.Yaw = float32(yaw) * (1.0 / 256)
// np.Pitch = float32(pitch) * (1.0 / 256)
// g.wd.Entities[np.entityID] = np //把该玩家添加到全局实体表里面
// return nil
// }
func handleWindowItemsPacket(c *Client, p pk.Packet) (err error) { func handleWindowItemsPacket(c *Client, p pk.Packet) (err error) {
r := bytes.NewReader(p.Data) r := bytes.NewReader(p.Data)
var ( var (
@ -695,54 +590,3 @@ func sendPlayerPositionAndLookPacket(c *Client) {
pk.Boolean(c.OnGround), pk.Boolean(c.OnGround),
)) ))
} }
// func sendPlayerLookPacket(g *Client) {
// var data []byte
// data = append(data, pk.PackFloat(g.player.Yaw)...)
// data = append(data, pk.PackFloat(g.player.Pitch)...)
// data = append(data, pk.PackBoolean(g.player.OnGround))
// g.sendChan <- pk.Packet{
// ID: 0x12,
// Data: data,
// }
// }
// func sendPlayerPositionPacket(g *Client) {
// var data []byte
// data = append(data, pk.PackDouble(g.player.X)...)
// data = append(data, pk.PackDouble(g.player.Y)...)
// data = append(data, pk.PackDouble(g.player.Z)...)
// data = append(data, pk.PackBoolean(g.player.OnGround))
// g.sendChan <- pk.Packet{
// ID: 0x10,
// Data: data,
// }
// }
// func sendClientStatusPacket(g *Client, status int32) {
// data := pk.PackVarInt(status)
// g.sendChan <- pk.Packet{
// ID: 0x03,
// Data: data,
// }
// }
// func sendPlayerDiggingPacket(g *Client, status int32, x, y, z int, face Face) {
// data := pk.PackVarInt(status)
// data = append(data, pk.PackPosition(x, y, z)...)
// data = append(data, byte(face))
// g.sendChan <- pk.Packet{
// ID: 0x18,
// Data: data,
// }
// }
// func sendUseItemPacket(g *Client, hand int32) {
// data := pk.PackVarInt(hand)
// g.sendChan <- pk.Packet{
// ID: 0x2A,
// Data: data,
// }
// }

217
bot/world/chunk.go
View File

@ -1,122 +1,65 @@
package world package world
import ( import (
"github.com/Tnze/go-mc/nbt" "bytes"
// "fmt" "fmt"
pk "github.com/Tnze/go-mc/net/packet"
// "io" // "io"
"github.com/Tnze/go-mc/data"
pk "github.com/Tnze/go-mc/net/packet"
) )
func UnpackChunkDataPacket(p pk.Packet, hasSkyLight bool) (c *Chunk, x, z int, err error) { //DecodeChunkColumn decode the chunk data structure
var ( func DecodeChunkColumn(isFull bool, mask int32, data []byte) (*Chunk, error) {
X, Z pk.Int
FullChunk pk.Boolean
PrimaryBitMask pk.VarInt
Heightmaps struct{}
Data chunkData
BlockEntities blockEntities
)
p.Scan(&X, &Z, &FullChunk, &PrimaryBitMask, pk.NBT{V: &Heightmaps}, &Data, &BlockEntities)
//解析区块数据
cc, err := readChunkColumn(bool(FullChunk), int32(PrimaryBitMask), []byte(Data), hasSkyLight)
if err != nil {
panic(err)
}
return cc, int(X), int(Z), err
}
type chunkData []byte
type blockEntities []blockEntitie
type blockEntitie struct {
}
func (c *chunkData) Decode(r pk.DecodeReader) error {
var Size pk.VarInt
if err := Size.Decode(r); err != nil {
return err
}
*c = make([]byte, Size)
if _, err := r.Read(*c); err != nil {
return err
}
return nil
}
func (b *blockEntities) Decode(r pk.DecodeReader) error {
var NumberofBlockEntities pk.VarInt
if err := NumberofBlockEntities.Decode(r); err != nil {
return err
}
*b = make(blockEntities, NumberofBlockEntities)
decoder := nbt.NewDecoder(r)
for i := 0; i < int(NumberofBlockEntities); i++ {
if err := decoder.Decode(&(*b)[i]); err != nil {
return err
}
}
return nil
}
func readChunkColumn(isFull bool, mask int32, data []byte, hasSkyLight bool) (*Chunk, error) {
var c Chunk var c Chunk
// for sectionY := 0; sectionY < 16; sectionY++ { r := bytes.NewReader(data)
// if (mask & (1 << uint(sectionY))) != 0 { // Is the given bit set in the mask? for sectionY := 0; sectionY < 16; sectionY++ {
// BitsPerBlock, err := data.ReadByte() if (mask & (1 << uint(sectionY))) == 0 { // Is the given bit set in the mask?
// if err != nil { continue
// return nil, fmt.Errorf("read BitsPerBlock fail: %v", err) }
// } var (
// //读调色板 BlockCount pk.Short
// var palette []uint BitsPerBlock pk.Byte
// if BitsPerBlock < 9 { )
// length, err := pk.UnpackVarInt(data) if err := BlockCount.Decode(r); err != nil {
// if err != nil { return nil, err
// return nil, fmt.Errorf("read palette (id len) fail: %v", err) }
// } if err := BitsPerBlock.Decode(r); err != nil {
// palette = make([]uint, length) return nil, err
}
//读调色板
var palette []uint
if BitsPerBlock < 9 {
var length pk.VarInt
if err := length.Decode(r); err != nil {
return nil, fmt.Errorf("read palette (id len) fail: %v", err)
}
palette = make([]uint, length)
// for id := uint(0); id < uint(length); id++ { for id := uint(0); id < uint(length); id++ {
// stateID, err := pk.UnpackVarInt(data) var stateID pk.VarInt
// if err != nil { if err := stateID.Decode(r); err != nil {
// return nil, fmt.Errorf("read palette (id) fail: %v", err) return nil, fmt.Errorf("read palette (id) fail: %v", err)
// } }
// palette[id] = uint(stateID) palette[id] = uint(stateID)
// } }
// } }
// //Section数据 //Section数据
// DataArrayLength, err := pk.UnpackVarInt(data) var DataArrayLength pk.VarInt
// if err != nil { if err := DataArrayLength.Decode(r); err != nil {
// return nil, fmt.Errorf("read DataArrayLength fail: %v", err) return nil, fmt.Errorf("read DataArrayLength fail: %v", err)
// } }
// DataArray := make([]int64, DataArrayLength) DataArray := make([]int64, DataArrayLength)
// for i := 0; i < int(DataArrayLength); i++ { for i := 0; i < int(DataArrayLength); i++ {
// DataArray[i], err = pk.UnpackInt64(data) if err := (*pk.Long)(&DataArray[i]).Decode(r); err != nil {
// if err != nil { return nil, fmt.Errorf("read DataArray fail: %v", err)
// return nil, fmt.Errorf("read DataArray fail: %v", err) }
// } }
// } //用数据填充区块
// //用数据填充区块 fillSection(&c.sections[sectionY], perBits(byte(BitsPerBlock)), DataArray, palette)
// fillSection(&c.sections[sectionY], perBits(BitsPerBlock), DataArray, palette) }
// //throw BlockLight data
// _, err = pk.ReadNBytes(data, 2048)
// if err != nil {
// return nil, fmt.Errorf("read BlockLight fail: %v", err)
// }
// if hasSkyLight {
// //throw SkyLight data
// _, err = pk.ReadNBytes(data, 2048)
// if err != nil {
// return nil, fmt.Errorf("read SkyLight fail: %v", err)
// }
// }
// }
// }
// if isFull { //need recive Biomes datas // if isFull { //need recive Biomes datas
// _, err := pk.ReadNBytes(data, 256*4) // _, err := pk.ReadNBytes(data, 256*4)
// if err != nil { // if err != nil {
@ -128,35 +71,33 @@ func readChunkColumn(isFull bool, mask int32, data []byte, hasSkyLight bool) (*C
return &c, nil return &c, nil
} }
// const defaultBitsPerBlock = 14 func perBits(BitsPerBlock byte) uint {
switch {
case BitsPerBlock <= 4:
return 4
case BitsPerBlock < 9:
return uint(BitsPerBlock)
default:
return uint(data.BitsPerBlock) // DefaultBitsPerBlock
}
}
// func perBits(BitsPerBlock byte) uint { func fillSection(s *Section, bpb uint, DataArray []int64, palette []uint) {
// switch { mask := uint(1<<bpb - 1)
// case BitsPerBlock <= 4: for n := 0; n < 16*16*16; n++ {
// return 4 offset := uint(n * int(bpb))
// case BitsPerBlock < 9: data := uint(DataArray[offset/64])
// return uint(BitsPerBlock) data >>= offset % 64
// default: if offset%64 > 64-bpb {
// return defaultBitsPerBlock l := bpb + offset%64 - 64
// } data &= uint(DataArray[offset/64+1] << l)
// } }
data &= mask
// func fillSection(s *Section, bpb uint, DataArray []int64, palette []uint) { if bpb < 9 {
// mask := uint(1<<bpb - 1) s.blocks[n%16][n/(16*16)][n%(16*16)/16].id = palette[data]
// for n := 0; n < 16*16*16; n++ { } else {
// offset := uint(n * int(bpb)) s.blocks[n%16][n/(16*16)][n%(16*16)/16].id = data
// data := uint(DataArray[offset/64]) }
// data >>= offset % 64 }
// if offset%64 > 64-bpb { }
// l := bpb + offset%64 - 64
// data &= uint(DataArray[offset/64+1] << l)
// }
// data &= mask
// if bpb < 9 {
// s.blocks[n%16][n/(16*16)][n%(16*16)/16].id = palette[data]
// } else {
// s.blocks[n%16][n/(16*16)][n%(16*16)/16].id = data
// }
// }
// }

5
bot/world/world.go
View File

@ -70,3 +70,8 @@ type ChunkLoc struct {
// func (b Block) String() string { // func (b Block) String() string {
// return blockNameByID[b.id] // return blockNameByID[b.id]
// } // }
//LoadChunk load chunk at (x, z)
func (w *World) LoadChunk(x, z int, c *Chunk) {
w.Chunks[ChunkLoc{X: x, Z: z}] = c
}

66256
data/blocks.go
View File

File diff suppressed because it is too large Load Diff

2
nbt/README.md
View File

@ -1,2 +1,4 @@
# NBT # NBT
This package implement the Named Binary Tag format of Minecraft. This package implement the Named Binary Tag format of Minecraft.
# Docs
[![GoDoc](https://godoc.org/github.com/Tnze/go-mc/nbt?status.svg)](https://godoc.org/github.com/Tnze/go-mc/nbt)

2
net/packet/types.go
View File

@ -352,5 +352,5 @@ func (d *Double) Decode(r DecodeReader) error {
// Decode a NBT // Decode a NBT
func (n NBT) Decode(r DecodeReader) error { func (n NBT) Decode(r DecodeReader) error {
return nbt.NewDecoder(r).Decode(&n.V) return nbt.NewDecoder(r).Decode(n.V)
} }