Cosmic
/
bedrocktool
mirror of https://github.com/CosmicStar98/bedrocktool.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

switch to proper logger

This commit is contained in:
olebeck 2022-09-04 02:24:58 +02:00
parent d770b979f1
commit 1415bdc9c6
12 changed files with 169 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.gitignore vendored
View File

@ -1,14 +1,18 @@
token.json
.secrets
*.mcpack
*.zip
*.pcap
*.bmp
*.bin
bedrocktool
bedrocktool-*
__debug_bin
.vscode/launch.json
.vscode/*
keys.db
skins/
worlds/
test.bmp
.secrets
dist/

4
auth.go
View File

@ -2,11 +2,11 @@ package main
import (
"encoding/json"
"fmt"
"os"
"github.com/sandertv/gophertunnel/minecraft/auth"
"github.com/sandertv/gophertunnel/minecraft/realms"
"github.com/sirupsen/logrus"
"golang.org/x/oauth2"
)
@ -23,7 +23,7 @@ func GetTokenSource() oauth2.TokenSource {
panic(err)
}
if !token.Valid() {
fmt.Println("Refreshed token")
logrus.Info("Refreshed token")
write_token(new_token)
}

4
capture.go
View File

@ -97,8 +97,6 @@ func (c *CaptureCMD) Usage() string {
}
func (c *CaptureCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
log := logrus.New()
address, hostname, err := server_input(c.server_address)
if err != nil {
fmt.Fprintln(os.Stderr, err)
@ -116,7 +114,7 @@ func (c *CaptureCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interfac
_wl := sync.Mutex{}
err = create_proxy(ctx, log, address, nil, func(pk packet.Packet, proxy *ProxyContext, toServer bool) (packet.Packet, error) {
err = create_proxy(ctx, logrus.StandardLogger(), address, nil, func(pk packet.Packet, proxy *ProxyContext, toServer bool) (packet.Packet, error) {
_wl.Lock()
dump_packet(toServer, w, pk)
_wl.Unlock()

24
dns.go
View File

@ -2,24 +2,26 @@ package main
import (
"fmt"
"log"
"net"
"github.com/miekg/dns"
"github.com/sirupsen/logrus"
)
var override_dns = map[string]bool{
"geo.hivebedrock.network.": true,
}
func answerQuery(remote net.Addr, req *dns.Msg) (reply *dns.Msg) {
type DNSServer struct{}
func (d *DNSServer) answerQuery(remote net.Addr, req *dns.Msg) (reply *dns.Msg) {
reply = new(dns.Msg)
answered := false
for _, q := range req.Question {
switch q.Qtype {
case dns.TypeA:
log.Printf("Query for %s\n", q.Name)
logrus.Infof("Query for %s", q.Name)
if override_dns[q.Name] {
host, _, _ := net.SplitHostPort(remote.String())
@ -35,7 +37,8 @@ func answerQuery(remote net.Addr, req *dns.Msg) (reply *dns.Msg) {
}
}
if ip == "" {
log.Panicf("query from outside of own network??")
logrus.Warn("query from outside of own network")
continue
}
rr, err := dns.NewRR(fmt.Sprintf("%s A %s", q.Name, ip))
@ -65,12 +68,12 @@ func answerQuery(remote net.Addr, req *dns.Msg) (reply *dns.Msg) {
return reply
}
func dns_handler(w dns.ResponseWriter, req *dns.Msg) {
func (d *DNSServer) handler(w dns.ResponseWriter, req *dns.Msg) {
var reply *dns.Msg
switch req.Opcode {
case dns.OpcodeQuery:
reply = answerQuery(w.RemoteAddr(), req)
reply = d.answerQuery(w.RemoteAddr(), req)
default:
reply = new(dns.Msg)
}
@ -80,16 +83,17 @@ func dns_handler(w dns.ResponseWriter, req *dns.Msg) {
}
func init_dns() {
dns.HandleFunc(".", dns_handler)
d := DNSServer{}
dns.HandleFunc(".", d.handler)
server := &dns.Server{Addr: ":53", Net: "udp"}
go func() {
fmt.Printf("Starting dns at %s:53\n", GetLocalIP())
logrus.Infof("Starting dns at %s:53\n", GetLocalIP())
err := server.ListenAndServe()
defer server.Shutdown()
if err != nil {
log.Printf("Failed to start dns server: %s\n ", err.Error())
println("you may have to use bedrockconnect")
logrus.Warnf("Failed to start dns server: %s\n ", err.Error())
logrus.Info("you may have to use bedrockconnect")
}
}()
}

8
main.go
View File

@ -11,6 +11,7 @@ import (
"syscall"
"github.com/google/subcommands"
"github.com/sirupsen/logrus"
)
const TOKEN_FILE = "token.json"
@ -22,7 +23,7 @@ var G_preload_packs bool
var G_exit []func() = []func(){}
func exit() {
fmt.Printf("\nExiting\n")
logrus.Info("\nExiting\n")
for i := len(G_exit) - 1; i >= 0; i-- { // go through cleanup functions reversed
G_exit[i]()
}
@ -37,7 +38,10 @@ func register_command(sub subcommands.Command) {
}
func main() {
fmt.Printf("bedrocktool version: %s\n", version)
logrus.SetLevel(logrus.DebugLevel)
if version != "" {
logrus.Info("bedrocktool version: %s\n", version)
}
ctx, cancel := context.WithCancel(context.Background())

20
merge.go
View File

@ -18,7 +18,6 @@ import (
type MergeCMD struct {
worlds []string
legacy bool
log *logrus.Logger
}
func (*MergeCMD) Name() string { return "merge" }
@ -33,26 +32,24 @@ func (c *MergeCMD) Usage() string {
}
func (c *MergeCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
c.log = logrus.New()
if f.NArg() == 0 {
fmt.Println("you need to specify 1 or more worlds")
logrus.Error("you need to specify 1 or more worlds")
return 1
}
c.worlds = f.Args()
out_name := c.worlds[0] + "-merged"
prov_out, err := mcdb.New(c.log, out_name, opt.DefaultCompression)
prov_out, err := mcdb.New(logrus.StandardLogger(), out_name, opt.DefaultCompression)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to open output %s\n", err)
}
for i, world_name := range c.worlds {
first := i == 0
fmt.Printf("Adding %s\n", world_name)
logrus.Infof("Adding %s", world_name)
s, err := os.Stat(world_name)
if errors.Is(err, os.ErrNotExist) {
fmt.Fprintf(os.Stderr, "%s not found\n", world_name)
logrus.Errorf("%s not found", world_name)
}
if !s.IsDir() { // if its a zip temporarily unpack it to read it
f, _ := os.Open(world_name)
@ -76,7 +73,7 @@ func (c *MergeCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{
time.Sleep(1 * time.Second)
if err := zip_folder(out_name+".mcworld", out_name); err != nil {
fmt.Fprintf(os.Stderr, "zipping: %s\n", err)
logrus.Info("zipping: %s", err)
return 1
}
@ -85,8 +82,7 @@ func (c *MergeCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{
}
func (c *MergeCMD) merge_worlds(prov_out *mcdb.Provider, folder string, first bool) error {
log := logrus.New()
prov_in, err := mcdb.New(log, folder, opt.DefaultCompression)
prov_in, err := mcdb.New(logrus.StandardLogger(), folder, opt.DefaultCompression)
if err != nil {
return err
}
@ -127,12 +123,12 @@ func (c *MergeCMD) merge_worlds(prov_out *mcdb.Provider, folder string, first bo
}
if first {
fmt.Print("Applying Settings, level.dat\n\n")
logrus.Debug("Applying Settings and level.dat")
prov_out.SaveSettings(prov_in.Settings())
out_ld := prov_out.LevelDat()
copier.Copy(out_ld, prov_in.LevelDat())
}
fmt.Printf("Added: %d\n", count)
logrus.Infof("Added: %d", count)
return nil
}

44
proxy.go
View File

@ -8,6 +8,7 @@ import (
"sync"
"github.com/sandertv/gophertunnel/minecraft"
"github.com/sandertv/gophertunnel/minecraft/protocol"
"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
"github.com/sandertv/gophertunnel/minecraft/resource"
"github.com/sirupsen/logrus"
@ -35,6 +36,7 @@ type ProxyContext struct {
server *minecraft.Conn
client *minecraft.Conn
listener *minecraft.Listener
commands map[string]IngameCommand
}
type (
@ -60,6 +62,33 @@ func (p *ProxyContext) sendPopup(text string) {
}
}
type IngameCommand struct {
exec func(cmdline []string) bool
cmd protocol.Command
}
func (p *ProxyContext) addCommand(cmd IngameCommand) {
p.commands[cmd.cmd.Name] = cmd
}
func (p *ProxyContext) CommandHandlerPacketCB(pk packet.Packet, proxy *ProxyContext, toServer bool) (packet.Packet, error) {
switch pk := pk.(type) {
case *packet.CommandRequest:
cmd := strings.Split(pk.CommandLine, " ")
name := cmd[0][1:]
if h, ok := p.commands[name]; ok {
if h.exec(cmd[1:]) {
pk = nil
}
}
case *packet.AvailableCommands:
for _, ic := range p.commands {
pk.Commands = append(pk.Commands, ic.cmd)
}
}
return pk, nil
}
func proxyLoop(ctx context.Context, proxy *ProxyContext, toServer bool, packetCBs []PacketCallback) error {
var c1, c2 *minecraft.Conn
if toServer {
@ -106,17 +135,18 @@ func create_proxy(ctx context.Context, log *logrus.Logger, server_address string
GetTokenSource() // ask for login before listening
proxy := ProxyContext{}
proxy.commands = make(map[string]IngameCommand)
var packs []*resource.Pack
if G_preload_packs {
fmt.Println("Preloading resourcepacks")
log.Info("Preloading resourcepacks")
serverConn, err := connect_server(ctx, server_address, nil, true)
if err != nil {
return fmt.Errorf("failed to connect to %s: %s", server_address, err)
}
serverConn.Close()
packs = serverConn.ResourcePacks()
fmt.Printf("%d packs loaded\n", len(packs))
log.Infof("%d packs loaded\n", len(packs))
}
_status := minecraft.NewStatusProvider("Server")
@ -132,7 +162,7 @@ func create_proxy(ctx context.Context, log *logrus.Logger, server_address string
}
defer proxy.listener.Close()
fmt.Printf("Listening on %s\n", proxy.listener.Addr())
log.Infof("Listening on %s\n", proxy.listener.Addr())
c, err := proxy.listener.Accept()
if err != nil {
@ -159,12 +189,16 @@ func create_proxy(ctx context.Context, log *logrus.Logger, server_address string
}
wg := sync.WaitGroup{}
cbs := []PacketCallback{
proxy.CommandHandlerPacketCB,
packetCB,
}
// server to client
wg.Add(1)
go func() {
defer wg.Done()
if err := proxyLoop(ctx, &proxy, false, []PacketCallback{packetCB}); err != nil {
if err := proxyLoop(ctx, &proxy, false, cbs); err != nil {
log.Error(err)
return
}
@ -174,7 +208,7 @@ func create_proxy(ctx context.Context, log *logrus.Logger, server_address string
wg.Add(1)
go func() {
defer wg.Done()
if err := proxyLoop(ctx, &proxy, true, []PacketCallback{packetCB}); err != nil {
if err := proxyLoop(ctx, &proxy, true, cbs); err != nil {
log.Error(err)
return
}

27
replay.go
View File

@ -1,8 +1,8 @@
package main
import (
"bytes"
"context"
"fmt"
"os"
"reflect"
"time"
@ -11,6 +11,7 @@ import (
"github.com/google/gopacket"
"github.com/google/gopacket/pcapgo"
"github.com/sandertv/gophertunnel/minecraft"
"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
"github.com/sirupsen/logrus"
)
@ -29,7 +30,9 @@ func (d PayloadDecoder) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback)
}
func create_replay_connection(ctx context.Context, log *logrus.Logger, filename string, onConnect ConnectCallback, packetCB PacketCallback) error {
fmt.Printf("Reading replay %s\n", filename)
log.Infof("Reading replay %s", filename)
OLD_BROKEN := true
f, err := os.Open(filename)
if err != nil {
@ -53,14 +56,16 @@ func create_replay_connection(ctx context.Context, log *logrus.Logger, filename
onConnect(&proxy)
}
/* FOR OLD BROKEN CAPTURES
fake_head := packet.Header{
PacketID: packet.IDLevelChunk,
var fake_header []byte
if OLD_BROKEN {
// FOR OLD BROKEN CAPTURES
fake_head := packet.Header{
PacketID: packet.IDLevelChunk,
}
fake_header_w := bytes.NewBuffer(nil)
fake_head.Write(fake_header_w)
fake_header = fake_header_w.Bytes()
}
fake_header_w := bytes.NewBuffer(nil)
fake_head.Write(fake_header_w)
fake_header := fake_header_w.Bytes()
*/
start := time.Time{}
for {
@ -77,7 +82,9 @@ func create_replay_connection(ctx context.Context, log *logrus.Logger, filename
continue
}
// payload = append(fake_header, payload...)
if OLD_BROKEN {
payload = append(fake_header, payload...)
}
pk_data, err := minecraft.ParseData(payload, dummy_conn)
if err != nil {

8
skins-proxy.go
View File

@ -29,24 +29,22 @@ func (c *SkinProxyCMD) Usage() string {
}
func (c *SkinProxyCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
log := logrus.New()
address, hostname, err := server_input(c.server_address)
if err != nil {
fmt.Fprintln(os.Stderr, err)
logrus.Error(err)
return 1
}
out_path := fmt.Sprintf("skins/%s", hostname)
os.MkdirAll(out_path, 0o755)
err = create_proxy(ctx, log, address, nil, func(pk packet.Packet, proxy *ProxyContext, toServer bool) (packet.Packet, error) {
err = create_proxy(ctx, logrus.StandardLogger(), address, nil, func(pk packet.Packet, proxy *ProxyContext, toServer bool) (packet.Packet, error) {
if !toServer {
process_packet_skins(proxy.client, out_path, pk, c.filter)
}
return pk, nil
})
if err != nil {
fmt.Fprintln(os.Stderr, err)
logrus.Error(err)
return 1
}
return 0

9
skins.go
View File

@ -19,6 +19,7 @@ import (
"github.com/sandertv/gophertunnel/minecraft"
"github.com/sandertv/gophertunnel/minecraft/protocol"
"github.com/sandertv/gophertunnel/minecraft/protocol/packet"
"github.com/sirupsen/logrus"
)
type Skin struct {
@ -54,7 +55,7 @@ func (skin *Skin) WriteCape(output_path string) error {
// WriteAnimations writes skin animations to the folder
func (skin *Skin) WriteAnimations(output_path string) error {
fmt.Printf("Warn: %s has animations (unimplemented)", output_path)
logrus.Warnf("%s has animations (unimplemented)", output_path)
return nil
}
@ -181,7 +182,7 @@ func write_skin(output_path, name string, skin protocol.Skin, filter string) {
if !strings.HasPrefix(name, filter) {
return
}
fmt.Printf("Writing skin for %s\n", name)
logrus.Infof("Writing skin for %s\n", name)
_skin := &Skin{skin}
if err := _skin.Write(output_path, name); err != nil {
fmt.Fprintf(os.Stderr, "Error writing skin: %s\n", err)
@ -264,8 +265,8 @@ func (c *SkinCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{}
return 1
}
println("Connected")
println("Press ctrl+c to exit")
logrus.Info("Connected")
logrus.Info("Press ctrl+c to exit")
os.MkdirAll(out_path, 0o755)

11
utils.go
View File

@ -23,6 +23,7 @@ import (
"unsafe"
"github.com/sandertv/gophertunnel/minecraft"
"github.com/sirupsen/logrus"
//"github.com/sandertv/gophertunnel/minecraft/gatherings"
"github.com/sandertv/gophertunnel/minecraft/protocol"
@ -120,7 +121,7 @@ func connect_server(ctx context.Context, address string, ClientData *login.Clien
cd = *ClientData
}
fmt.Printf("Connecting to %s\n", address)
logrus.Infof("Connecting to %s\n", address)
serverConn, err = minecraft.Dialer{
TokenSource: GetTokenSource(),
ClientData: cd,
@ -326,13 +327,9 @@ func PacketLogger(header packet.Header, payload []byte, src, dst net.Addr) {
}
switch pk := pk.(type) {
case *packet.Disconnect:
fmt.Printf("Disconnect: %s", pk.Message)
case *packet.Event:
fmt.Printf("Event: %d %+v\n", pk.EventType, pk.EventData)
case *packet.LevelEvent:
fmt.Printf("LevelEvent: %+v\n", pk)
logrus.Infof("Disconnect: %s", pk.Message)
}
fmt.Printf("%s 0x%x, %s\n", dir, pk.ID(), pk_name)
logrus.Debugf("%s 0x%x, %s\n", dir, pk.ID(), pk_name)
}
func img2rgba(img *image.RGBA) []color.RGBA {

154
world.go
View File

@ -56,8 +56,6 @@ type WorldState struct {
PlayerPos TPlayerPos
proxy *ProxyContext
log *logrus.Logger
// ui
ui MapUI
}
@ -74,49 +72,14 @@ func NewWorldState() *WorldState {
}
}
type IngameCommand struct {
exec func(w *WorldState, cmdline []string) bool
cmd protocol.Command
}
var IngameCommands = map[string]IngameCommand{
"setname": {
exec: setnameCommand,
cmd: protocol.Command{
Name: "setname",
Description: "set user defined name for this world",
Overloads: []protocol.CommandOverload{
{
Parameters: []protocol.CommandParameter{
{
Name: "name",
Type: protocol.CommandArgTypeFilepath,
Optional: false,
},
},
},
},
},
},
"void": {
exec: toggleVoid,
cmd: protocol.Command{
Name: "void",
Description: "toggle if void generator should be used",
},
},
}
func setnameCommand(w *WorldState, cmdline []string) bool {
w.WorldName = strings.Join(cmdline, " ")
w.proxy.sendMessage(fmt.Sprintf("worldName is now: %s", w.WorldName))
return true
}
func toggleVoid(w *WorldState, cmdline []string) bool {
w.voidgen = !w.voidgen
w.proxy.sendMessage(fmt.Sprintf("using void generator: %t", w.voidgen))
return true
var dimension_ids = map[uint8]world.Dimension{
0: world.Overworld,
1: world.Nether,
2: world.End,
// < 1.18
10: world.Overworld_legacy,
11: world.Nether,
12: world.End,
}
var (
@ -140,7 +103,6 @@ type WorldCMD struct {
server_address string
packs bool
enableVoid bool
log *logrus.Logger
}
func (*WorldCMD) Name() string { return "worlds" }
@ -157,8 +119,6 @@ func (c *WorldCMD) Usage() string {
}
func (c *WorldCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
c.log = logrus.New()
server_address, hostname, err := server_input(c.server_address)
if err != nil {
fmt.Fprintln(os.Stderr, err)
@ -166,13 +126,12 @@ func (c *WorldCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{
}
w := NewWorldState()
w.log = c.log
w.voidgen = c.enableVoid
w.ServerName = hostname
w.withPacks = c.packs
w.ctx = ctx
err = create_proxy(ctx, c.log, server_address, w.OnConnect, func(pk packet.Packet, proxy *ProxyContext, toServer bool) (packet.Packet, error) {
err = create_proxy(ctx, logrus.StandardLogger(), server_address, w.OnConnect, func(pk packet.Packet, proxy *ProxyContext, toServer bool) (packet.Packet, error) {
if toServer {
pk = w.ProcessPacketClient(pk)
} else {
@ -187,20 +146,22 @@ func (c *WorldCMD) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{
return 0
}
var dimension_ids = map[uint8]world.Dimension{
0: world.Overworld,
1: world.Nether,
2: world.End,
// < 1.18
10: world.Overworld_legacy,
11: world.Nether,
12: world.End,
func (w *WorldState) setnameCommand(cmdline []string) bool {
w.WorldName = strings.Join(cmdline, " ")
w.proxy.sendMessage(fmt.Sprintf("worldName is now: %s", w.WorldName))
return true
}
func (w *WorldState) toggleVoid(cmdline []string) bool {
w.voidgen = !w.voidgen
w.proxy.sendMessage(fmt.Sprintf("using void generator: %t", w.voidgen))
return true
}
func (w *WorldState) ProcessLevelChunk(pk *packet.LevelChunk) {
ch, blockNBTs, err := chunk.NetworkDecode(uint32(pk.HighestSubChunk), pk.RawPayload, int(pk.SubChunkCount), w.Dim.Range(), w.ispre118)
if err != nil {
log.Print(err.Error())
logrus.Error(err)
return
}
if blockNBTs != nil {
@ -239,22 +200,24 @@ func (w *WorldState) ProcessSubChunk(pk *packet.SubChunk) {
pos_to_redraw := make(map[protocol.ChunkPos]bool)
for _, sub := range pk.SubChunkEntries {
abs_x := pk.Position[0] + int32(sub.Offset[0])
abs_y := pk.Position[1] + int32(sub.Offset[1])
abs_z := pk.Position[2] + int32(sub.Offset[2])
pos := protocol.ChunkPos{abs_x, abs_z}
pos3 := protocol.SubChunkPos{abs_x, abs_y, abs_z}
var (
abs_x = pk.Position[0] + int32(sub.Offset[0])
abs_y = pk.Position[1] + int32(sub.Offset[1])
abs_z = pk.Position[2] + int32(sub.Offset[2])
subpos = protocol.SubChunkPos{abs_x, abs_y, abs_z}
pos = protocol.ChunkPos{abs_x, abs_z}
)
ch := w.chunks[pos]
if ch == nil {
fmt.Printf("the server didnt send the chunk before the subchunk!\n")
logrus.Errorf("the server didnt send the chunk before the subchunk!")
continue
}
blockNBT, err := ch.ApplySubChunkEntry(uint8(abs_y), &sub)
if err != nil {
fmt.Print(err)
logrus.Error(err)
}
if blockNBT != nil {
w.blockNBT[pos3] = blockNBT
w.blockNBT[subpos] = blockNBT
}
pos_to_redraw[pos] = true
@ -275,11 +238,10 @@ func (w *WorldState) ProcessAnimate(pk *packet.Animate) {
}
func (w *WorldState) ProcessChangeDimension(pk *packet.ChangeDimension) {
fmt.Printf("ChangeDimension %d\n", pk.Dimension)
if len(w.chunks) > 0 {
w.SaveAndReset()
} else {
fmt.Println("Info: Skipping save because the world didnt contain any chunks")
logrus.Info("Skipping save because the world didnt contain any chunks.")
w.Reset()
}
dim_id := pk.Dimension
@ -289,15 +251,6 @@ func (w *WorldState) ProcessChangeDimension(pk *packet.ChangeDimension) {
w.Dim = dimension_ids[uint8(dim_id)]
}
func (w *WorldState) ProcessCommand(pk *packet.CommandRequest) bool {
cmd := strings.Split(pk.CommandLine, " ")
name := cmd[0][1:]
if h, ok := IngameCommands[name]; ok {
return h.exec(w, cmd[1:])
}
return false
}
func (w *WorldState) SetPlayerPos(Position mgl32.Vec3, Pitch, Yaw, HeadYaw float32) {
last := w.PlayerPos
w.PlayerPos = TPlayerPos{
@ -321,14 +274,14 @@ func (w *WorldState) Reset() {
// writes the world to a folder, resets all the chunks
func (w *WorldState) SaveAndReset() {
fmt.Printf("Saving world %s\n", w.WorldName)
logrus.Infof("Saving world %s", w.WorldName)
// open world
folder := path.Join("worlds", fmt.Sprintf("%s/%s", w.ServerName, w.WorldName))
os.RemoveAll(folder)
os.MkdirAll(folder, 0o777)
provider, err := mcdb.New(w.log, folder, opt.DefaultCompression)
provider, err := mcdb.New(logrus.StandardLogger(), folder, opt.DefaultCompression)
if err != nil {
log.Fatal(err)
}
@ -427,7 +380,7 @@ func (w *WorldState) SaveAndReset() {
ld.ShowBorderEffect = gr.Value.(bool)
// todo
default:
fmt.Printf("unknown gamerule: %s\n", gr.Name)
logrus.Warnf("unknown gamerule: %s\n", gr.Name)
}
}
@ -444,7 +397,7 @@ func (w *WorldState) SaveAndReset() {
w.worldCounter += 1
for k, p := range w.packs {
fmt.Printf("Adding resource pack: %s\n", k)
logrus.Infof("Adding resource pack: %s\n", k)
pack_folder := path.Join(folder, "resource_packs", k)
os.MkdirAll(pack_folder, 0o755)
data := make([]byte, p.Len())
@ -458,7 +411,7 @@ func (w *WorldState) SaveAndReset() {
if err := zip_folder(filename, folder); err != nil {
fmt.Println(err)
}
fmt.Printf("Saved: %s\n", filename)
logrus.Infof("Saved: %s\n", filename)
os.RemoveAll(folder)
w.Reset()
}
@ -518,6 +471,33 @@ func (w *WorldState) OnConnect(proxy *ProxyContext) {
}
}
}()
proxy.addCommand(IngameCommand{
exec: w.setnameCommand,
cmd: protocol.Command{
Name: "setname",
Description: "set user defined name for this world",
Overloads: []protocol.CommandOverload{
{
Parameters: []protocol.CommandParameter{
{
Name: "name",
Type: protocol.CommandArgTypeFilepath,
Optional: false,
},
},
},
},
},
})
proxy.addCommand(IngameCommand{
exec: w.toggleVoid,
cmd: protocol.Command{
Name: "void",
Description: "toggle if void generator should be used",
},
})
}
func (w *WorldState) ProcessPacketClient(pk packet.Packet) packet.Packet {
@ -537,10 +517,6 @@ func (w *WorldState) ProcessPacketClient(pk packet.Packet) packet.Packet {
}
case *packet.Animate:
w.ProcessAnimate(pk)
case *packet.CommandRequest:
if w.ProcessCommand(pk) {
pk = nil
}
}
return pk
}
@ -555,10 +531,6 @@ func (w *WorldState) ProcessPacketServer(pk packet.Packet) packet.Packet {
w.proxy.sendPopup(fmt.Sprintf("%d chunks loaded\nname: %s", len(w.chunks), w.WorldName))
case *packet.SubChunk:
w.ProcessSubChunk(pk)
case *packet.AvailableCommands:
for _, ic := range IngameCommands {
pk.Commands = append(pk.Commands, ic.cmd)
}
}
return pk
}