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

Add example programs that sniff the RegistryCodec.nbt

Browse Source
This commit is contained in:
Tnze
2023-04-05 18:04:05 +08:00
parent 2e838101db
commit a9ab97292d
2 changed files with 91 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
examples/dazeReadCommand/daze.go
View File

@ -1,159 +0,0 @@
// Daze could join an offline-mode server as client.
// Just standing there and do nothing. Automatically reborn after five seconds of death.
package main
import (
"flag"
"io"
"log"
"strconv"
//"github.com/mattn/go-colorable"
"github.com/Tnze/go-mc/bot"
"github.com/Tnze/go-mc/bot/basic"
"github.com/Tnze/go-mc/bot/screen"
_ "github.com/Tnze/go-mc/data/lang/zh-cn"
"github.com/Tnze/go-mc/data/packetid"
pk "github.com/Tnze/go-mc/net/packet"
)
var (
address = flag.String("address", "127.0.0.1", "The server address")
client *bot.Client
player *basic.Player
screenManager *screen.Manager
)
func main() {
flag.Parse()
// log.SetOutput(colorable.NewColorableStdout())
client = bot.NewClient()
client.Auth.Name = "Daze"
player = basic.NewPlayer(client, basic.DefaultSettings, basic.EventsListener{})
client.Events.AddListener(bot.PacketHandler{
ID: packetid.ClientboundCommands,
Priority: 50,
F: onCommands,
})
// Login
err := client.JoinServer(*address)
if err != nil {
log.Fatal(err)
}
log.Println("Login success")
// JoinGame
for {
if err = client.HandleGame(); err == nil {
panic("HandleGame never return nil")
}
log.Fatal(err)
}
}
func onCommands(p pk.Packet) error {
var nodes []Node
var root pk.VarInt
err := p.Scan(pk.Array(&nodes), &root)
if err != nil {
return err
}
log.Printf("Root index: %d", root)
return nil
}
type Node struct{}
func (n Node) ReadFrom(r io.Reader) (int64, error) {
var Flags pk.Byte
var Children []pk.VarInt
var Redirect pk.VarInt
var Name pk.String
var Parser pk.Identifier
Properties := Prop{Type: &Parser}
var SuggestionsType pk.Identifier
m, err := pk.Tuple{
&Flags,
pk.Array(&Children),
pk.Opt{
Has: func() bool { return Flags&0x08 != 0 },
Field: &Redirect,
},
pk.Opt{
Has: func() bool { return Flags&0x03 == 2 || Flags&0x03 == 1 },
Field: &Name,
},
pk.Opt{
Has: func() bool { return Flags&0x03 == 2 },
Field: pk.Tuple{&Parser, &Properties},
},
pk.Opt{
Has: func() bool { return Flags&0x10 != 0 },
Field: &SuggestionsType,
},
}.ReadFrom(r)
if err != nil {
return m, err
}
var redirect string
if Flags&0x08 != 0 {
redirect = "Redirect: " + strconv.Itoa(int(Redirect))
}
var parser string
if Flags&0x03 == 2 {
redirect = string("Parser: " + Parser)
}
log.Printf("Type: %2d\tName: %s\tChildren: %v\t%v\t%v", Flags&0x03, Name, Children, redirect, parser)
return m, nil
}
type Prop struct {
Type *pk.Identifier
}
func (p Prop) ReadFrom(r io.Reader) (int64, error) {
var Flags pk.Byte
switch *p.Type {
case "brigadier:double":
var Min, Max pk.Double
return pk.Tuple{
&Flags,
pk.Opt{Has: func() bool { return Flags&0x01 != 0 }, Field: &Min},
pk.Opt{Has: func() bool { return Flags&0x02 != 0 }, Field: &Max},
}.ReadFrom(r)
case "brigadier:float":
var Min, Max pk.Float
return pk.Tuple{
&Flags,
pk.Opt{Has: func() bool { return Flags&0x01 != 0 }, Field: &Min},
pk.Opt{Has: func() bool { return Flags&0x02 != 0 }, Field: &Max},
}.ReadFrom(r)
case "brigadier:integer":
var Min, Max pk.Int
return pk.Tuple{
&Flags,
pk.Opt{Has: func() bool { return Flags&0x01 != 0 }, Field: &Min},
pk.Opt{Has: func() bool { return Flags&0x02 != 0 }, Field: &Max},
}.ReadFrom(r)
case "brigadier:long":
var Min, Max pk.Long
return pk.Tuple{
&Flags,
pk.Opt{Has: func() bool { return Flags&0x01 != 0 }, Field: &Min},
pk.Opt{Has: func() bool { return Flags&0x02 != 0 }, Field: &Max},
}.ReadFrom(r)
case "brigadier:string":
return new(pk.VarInt).ReadFrom(r)
case "minecraft:entity":
return new(pk.Byte).ReadFrom(r)
case "minecraft:score_holder":
return new(pk.Byte).ReadFrom(r)
case "minecraft:range":
return new(pk.Boolean).ReadFrom(r)
default:
return 0, nil
}
}

91
examples/sniffRegistryCodec/daze.go Normal file
View File

@ -0,0 +1,91 @@
// sniffRegistryCodec is an example that acts as a client,
// connects to the server and saves its RegistryCodec to a .nbt file.
package main
import (
"flag"
"log"
"os"
//"github.com/mattn/go-colorable"
"github.com/Tnze/go-mc/bot"
"github.com/Tnze/go-mc/bot/basic"
_ "github.com/Tnze/go-mc/data/lang/zh-cn"
"github.com/Tnze/go-mc/data/packetid"
"github.com/Tnze/go-mc/nbt"
pk "github.com/Tnze/go-mc/net/packet"
)
var (
address = flag.String("address", "127.0.0.1", "The server address")
client *bot.Client
player *basic.Player
)
func main() {
flag.Parse()
// log.SetOutput(colorable.NewColorableStdout())
client = bot.NewClient()
client.Auth.Name = "Daze"
player = basic.NewPlayer(client, basic.DefaultSettings, basic.EventsListener{})
// To receive the raw NBT data, create a new packet handler
// instead of just reading player.RegistryCodec in GameStart event.
client.Events.AddListener(bot.PacketHandler{
ID: packetid.ClientboundLogin,
Priority: 50,
F: onLogin,
})
// Login
err := client.JoinServer(*address)
if err != nil {
log.Fatal(err)
}
log.Println("Login success")
// JoinGame
for {
if err = client.HandleGame(); err == nil {
panic("HandleGame never return nil")
}
log.Fatal(err)
}
}
func onLogin(p pk.Packet) error {
var DimensionNames []pk.Identifier
var RegistryCodec nbt.RawMessage
err := p.Scan(
new(pk.Int), // Entity ID
new(pk.Boolean), // Is hardcore
new(pk.Byte), // Gamemode
new(pk.Byte), // Previous Gamemode
pk.Array(&DimensionNames), // Dimension Names
pk.NBT(&RegistryCodec), // Registry Codec (Only care about this)
// ...Ignored
)
if err != nil {
return err
}
err = saveToFile("RegistryCodec.nbt", RegistryCodec)
if err != nil {
return err
}
log.Print("Successfully written RegistryCodec.nbt")
return nil
}
func saveToFile(filename string, value any) (err error) {
f, err := os.Create(filename)
if err != nil {
return nil
}
defer func(f *os.File) {
if err2 := f.Close(); err == nil {
err = err2
}
}(f)
return nbt.NewEncoder(f).Encode(value, "")
}