add 'version' subcommand to display build information

client/login.go

@@ -125,7 +125,7 @@ func (s *LoginClient) OnStart() (err error) {
 	return
 }
 
-func LoginRaw(c *proto.Conn, account *api.Account, addr string) (err error) {
+func LoginRaw(c *proto.Conn, account *api.Account) (err error) {
 	lc := &LoginClient{
 		Conn:    c,
 		Account: account,
@@ -161,7 +161,7 @@ func LoginNoSrv(connectTo string, account *api.Account) (c *proto.Conn, err erro
 	if err != nil {
 		return
 	}
-	err = LoginRaw(c, account, connectTo)
+	err = LoginRaw(c, account)
 	return
 }
 
@@ -174,6 +174,6 @@ func Login(connectTo string, account *api.Account) (c *proto.Conn, err error) {
 	if err != nil {
 		return
 	}
-	err = LoginRaw(c, account, connectTo)
+	err = LoginRaw(c, account)
 	return
 }

cmd/strom/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"debug/buildinfo"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -18,12 +19,26 @@ import (
 var ExpectedASubcommandErr = errors.New("expected a subcommand")
 var UnknownSubcommandErr = errors.New("unknown subcommand try 'strom help' for a list of subcommands")
 
+func Version(args []string) (err error) {
+	selfPath, err := os.Executable()
+	if err != nil {
+		return
+	}
+	info, err := buildinfo.ReadFile(selfPath)
+	if err != nil {
+		return
+	}
+	fmt.Println("strom cli ", info.Main.Version, " (", info.Main.Sum, ")")
+	return
+}
+
 var subcommands = map[string]func(args []string) error{
 	"offline-uuid": offline_uuid.Run,
 	"print-nbt":    print_nbt.Run,
 	"status":       status.Run,
 	"packet-spy":   packet_inspector.Run,
 	"api":          api.Run,
+	"version":      Version,
 }
 
 func Help(args []string) (err error) {
@@ -39,7 +54,7 @@ func mainE() (err error) {
 
 	// Debug stuff
 	slog.SetLogLoggerLevel(slog.LevelDebug)
-	//args = []string{"TEST", "api", "-name", "Admin_Else"}
+	//args = []string{"TEST", "version"}
 
 	if len(args) < 2 {
 		err = ExpectedASubcommandErr

cmd/strom/packet_inspector/main.go

@@ -116,7 +116,7 @@ func Run(args []string) (err error) {
 			return
 		}
 		c.DebugPrintPackets = []string{""}
-		err = client.LoginRaw(c, acc, *TargetAddr)
+		err = client.LoginRaw(c, acc)
 		if err != nil {
 			return
 		}

data/blocks.go

@@ -99,7 +99,12 @@ func StateIdFromBlocKAndStateMap(version string, name string, stateMap map[strin
 		err = BlockNotFoundErr
 		return
 	}
-	stateId, err = b.IdFromStateMap(stateMap)
+	if stateMap == nil {
+		stateId = b.DefaultState
+	} else {
+		stateId, err = b.IdFromStateMap(stateMap)
+	}
+
 	return
 }
 

level/anvil/chunk.go

@@ -1,5 +1,14 @@
 package anvil
 
+import (
+	"strings"
+	"unsafe"
+
+	"github.com/admin-else/strom/data"
+	"github.com/admin-else/strom/level"
+	"github.com/admin-else/strom/util"
+)
+
 type Chunk struct {
 	DataVersion      int32
 	Heightmaps       map[string][]int64
@@ -8,17 +17,64 @@ type Chunk struct {
 	Sections         []Section
 }
 
+const McPrefix = "minecraft:"
+
+func (c Chunk) ToStorage(version string) (toChunk *level.Chunk, err error) {
+	f := level.MakeBlockFormat(version)
+	toChunk = new(level.Chunk)
+
+	toChunk.Sections = make([]level.Section, len(c.Sections))
+	for i, s := range c.Sections {
+		pallete := make([]int32, len(s.BlockStates.Palette))
+		for j, p := range s.BlockStates.Palette {
+			pallete[j], err = data.StateIdFromBlocKAndStateMap(version, strings.TrimPrefix(p.Name, McPrefix), p.Properties)
+			if err != nil {
+				return
+			}
+		}
+		// this is probably fine
+		uintSlice := unsafe.Slice((*uint64)(unsafe.Pointer(unsafe.SliceData(s.BlockStates.Data))), len(s.BlockStates.Data))
+
+		toChunk.Sections[i].Blocks, err = f.Import(uintSlice, util.BpeByNum(float64(len(s.BlockStates.Palette))), pallete)
+		if err != nil {
+			return
+		}
+		toChunk.Sections[i].BlockCount = int16(level.CountStorage(toChunk.Sections[i].Blocks, 0))
+	}
+
+	for i, s := range c.Sections {
+		pallete := make([]int32, len(s.Biomes.Palette))
+		for j, p := range s.Biomes.Palette {
+			var b *data.Biome
+			b, ok := data.LookupBiomeByName(version, strings.TrimPrefix(p, McPrefix))
+			if !ok {
+				err = data.UnknownBiomeNameErr
+				return
+			}
+			pallete[j] = b.Id
+		}
+		// this is probably fine
+		uintSlice := unsafe.Slice((*uint64)(unsafe.Pointer(unsafe.SliceData(s.Biomes.Data))), len(s.Biomes.Data))
+
+		toChunk.Sections[i].Biomes, err = f.Import(uintSlice, util.BpeByNum(float64(len(pallete))), pallete)
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
 type Section struct {
 	Y           int8
 	BlockStates struct {
-		Data    []int64
+		Data    []int64 `nbt:"data,omitempty"`
 		Palette []struct {
 			Name       string
 			Properties map[string]string `nbt:"properties,omitempty"`
 		}
 	}
-	Biomes []struct {
+	Biomes struct {
-		Data    []int64
+		Data    []int64 `nbt:"data,omitempty"`
 		Palette []string
 	}
 }

level/storage.go

@@ -29,13 +29,30 @@ func (r StorageFormat) Import(data []uint64, bpe uint8, palette []int32) (s *Sto
 		return
 	}
 
-	if !slices.Contains(r.AvailableBpes, bpe) {
-		err = BpeNotAvailableErr
-		return
-	}
 	s = new(Storage)
 	s.format = r
 	s.resize(bpe)
+
+	if !slices.Contains(r.AvailableBpes, bpe) {
+		var newBpe uint8
+		for _, newBpe = range r.AvailableBpes {
+			if bpe < newBpe {
+				continue
+			}
+		}
+		var tmps *Storage
+		tmps, err = StorageFormat{
+			AvailableBpes: []uint8{bpe},
+			BiggestDirect: false,
+			Len:           r.Len,
+		}.ImportDataDirect(data)
+		if err != nil {
+			return
+		}
+		tmps.resize(newBpe)
+		data = tmps.data
+		bpe = newBpe
+	}
 	if bpe == 0 && len(palette) != 1 {
 		err = Bpe0PalletMustBeLenOneErr
 		return
@@ -238,3 +255,12 @@ func CompareStorage(a, b *Storage) bool {
 	}
 	return true
 }
+
+func CountStorage(s *Storage, v int32) (a int) {
+	for i := range s.format.Len {
+		if w, _ := s.Get(i); w == v {
+			a++
+		}
+	}
+	return
+}

server/login_server.go

@@ -163,15 +163,18 @@ func (l *LoginServer) OnEncryptionResponse(packet *v1_21_8.LoginToServerPacketEn
 		return
 	}
 
-	serverId := crypto.AuthDigest([]byte(l.ServerId), sharedSecret, l.PublicKeyBytes)
-	_, err = api.HasJoined(l.Requested.Name, serverId, "")
-	if err != nil {
-		return
-	}
 	err = l.SetSecret(sharedSecret)
 	if err != nil {
 		return
 	}
+
+	serverId := crypto.AuthDigest([]byte(l.ServerId), sharedSecret, l.PublicKeyBytes)
+	if l.OnlineMode {
+		_, err = api.HasJoined(l.Requested.Name, serverId, "")
+		if err != nil {
+			return
+		}
+	}
 	err = l.FinishLogin()
 	return
 }
@@ -234,12 +237,15 @@ func WithCompatibleVersions(versions ...int32) LoginServerSetting {
 
 func ServeLogin(c *proto.Conn, settings ...LoginServerSetting) (ret *LoginServer, err error) {
 	ret = &LoginServer{Conn: c}
+	ret.OnlineMode = true
+
 	ret.RegisterCritical(ret.OnDefault)
 	ret.RegisterCriticalUntilLatest(ret.OnHandshake)
 	ret.RegisterCriticalUntilLatest(ret.OnLoginStart)
 	ret.RegisterCriticalUntilLatest(ret.OnLoginAcknowledged)
 	ret.RegisterCriticalUntilLatest(ret.OnStatusRequest)
 	ret.RegisterCriticalUntilLatest(ret.OnStatusPing)
+	ret.RegisterCriticalUntilLatest(ret.OnEncryptionResponse)
 	for _, s := range settings {
 		s(ret)
 	}

server/server.go

@@ -78,6 +78,7 @@ func StartServerWithOnConn(listenAddr string, onConn func(c *proto.Conn) (err er
 			if errors.Is(connErr, ShutDownServerErr) {
 				running = false
 			}
+			c.Log.Error("closing connection", "err", connErr)
 			if connErr != nil {
 				connErr = Kick(c, text.Pretty(connErr.Error()), "")
 			}

tools/registry_data_hunter/main.go

@@ -25,6 +25,8 @@ func wontFail[T any](v T, err error) T {
 	return v
 }
 
+// THIS IS REDUNDANT USE LOGIN PACKET IN MINECRAFT DATA
+
 var (
 	// Edit these two
 	Version = "1.21.11"