diff --git a/.gitignore b/.gitignore
index 6033543..550b77f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -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/
diff --git a/auth.go b/auth.go
index d02fa69..57b2cff 100644
--- a/auth.go
+++ b/auth.go
@@ -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)
 	}
 
diff --git a/capture.go b/capture.go
index f456aa7..a862b08 100644
--- a/capture.go
+++ b/capture.go
@@ -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()
diff --git a/dns.go b/dns.go
index 6a1cec7..4aec3f3 100644
--- a/dns.go
+++ b/dns.go
@@ -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")
 		}
 	}()
 }
diff --git a/main.go b/main.go
index 1daf0a7..9688950 100644
--- a/main.go
+++ b/main.go
@@ -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())
 
diff --git a/merge.go b/merge.go
index baea9c4..7aed749 100644
--- a/merge.go
+++ b/merge.go
@@ -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
 }
 
diff --git a/proxy.go b/proxy.go
index 684629b..daee404 100644
--- a/proxy.go
+++ b/proxy.go
@@ -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
 		}
diff --git a/replay.go b/replay.go
index 5b6f52a..24cb898 100644
--- a/replay.go
+++ b/replay.go
@@ -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 {
diff --git a/skins-proxy.go b/skins-proxy.go
index 0f61bbc..823d145 100644
--- a/skins-proxy.go
+++ b/skins-proxy.go
@@ -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
diff --git a/skins.go b/skins.go
index 5b02f74..ced1f6b 100644
--- a/skins.go
+++ b/skins.go
@@ -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)
 
diff --git a/utils.go b/utils.go
index 6a576cf..3a3353c 100644
--- a/utils.go
+++ b/utils.go
@@ -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 {
diff --git a/world.go b/world.go
index d01101a..ba679c4 100644
--- a/world.go
+++ b/world.go
@@ -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
 }