items and struture loading

data/blocks.go

@@ -69,6 +69,7 @@ func LookupBlockByStateId(version string, stateId int32) (block *Block, ok bool)
 		if b.MinStateId <= stateId && stateId <= b.MaxStateId {
 			block = b
 			ok = true
+			return
 		}
 	}
 	return
@@ -100,6 +101,8 @@ func FromBlockState(version string, stateId int32) (b *Block, stateData map[stri
 	return
 }
 
+// TODO: mc stores these as strings so we will do the same
+
 func mcDataBlockStateTypeParse(n int32, s *BlockState) (v any, err error) {
 	switch s.Type {
 	case "int":

data/item.go

@@ -0,0 +1,49 @@
+package data
+
+//   {
+//    "id": 2,
+//    "name": "granite",
+//    "displayName": "Granite",
+//    "stackSize": 64
+//  },
+
+type Item struct {
+	Id          int32
+	Name        string
+	DisplayName string
+	StackSize   int32
+}
+
+var ItemsCache = make(map[string][]*Item)
+
+func ItemsForVersion(v string) (ret []*Item) {
+	var ok bool
+	if ret, ok = ItemsCache[v]; ok {
+		return
+	}
+	var b []*Item
+	must(LoadVersionedJson(v, "items", &b))
+	ItemsCache[v] = b
+	return b
+}
+
+func LookupItemById(version string, id int32) (item *Item, ok bool) {
+	for _, i := range ItemsForVersion(version) {
+		if i.Id == id {
+			item = i
+			ok = true
+			return
+		}
+	}
+	return
+}
+
+func LookupItemByName(version string, name string) (item *Item, ok bool) {
+	for _, i := range ItemsForVersion(version) {
+		if i.Name == name {
+			item = i
+			ok = true
+		}
+	}
+	return
+}

event/stdin.go

@@ -38,6 +38,7 @@ func (s *StdinHandler) ScanJob() {
 	}
 }
 func (s *StdinHandler) OnStart() (err error) {
+	s.Register(s.OnTick)
 	s.stdInChan = make(chan Stdin)
 	go s.ScanJob()
 	return

level/packet.go

@@ -2,8 +2,6 @@ package level
 
 import (
 	"encoding/binary"
-	"errors"
-	"fmt"
 	"io"
 	"math"
 
@@ -22,7 +20,8 @@ func UnpackArrayPalette(r io.Reader, bitsPerEntry uint8, numberOfEntries int) (d
 	}
 	var pallet []int32 // remember we can't use make because this is user-controlled data
 	for range palletLen {
-		entry, err := proto_base.DecodeVarInt(r)
+		var entry int32
+		entry, err = proto_base.DecodeVarInt(r)
 		if err != nil {
 			return
 		}
@@ -76,20 +75,18 @@ func LongsToData(data []uint64, n, bpe int32) (ret []int32) {
 	return
 }
 
+// UnpackBlockData minecraft does this at net.minecraft.world.chunk.PaletteProvider
 func UnpackBlockData(r io.Reader) (blocks []int32, err error) {
 	var bitsPerEntry uint8
 	err = binary.Read(r, binary.BigEndian, &bitsPerEntry)
 	if err != nil {
 		return
 	}
-	fmt.Println("blocks bpe", bitsPerEntry)
 	switch bitsPerEntry {
 	case 0:
 		blocks, err = UnpackSingleValuePalette(r, BlocksPerChunkSection)
-	case 1, 2, 3, 4:
+	case 1, 2, 3, 4, 5, 6, 7, 8:
 		blocks, err = UnpackArrayPalette(r, bitsPerEntry, BlocksPerChunkSection)
-	case 5, 6, 7, 8:
-		err = errors.New("unimplemented")
 	default:
 		blocks, err = UnpackLongData(r, bitsPerEntry, BlocksPerChunkSection)
 	}
@@ -106,7 +103,6 @@ func UnpackBiomeData(r io.Reader) (biomes []int32, err error) {
 	if err != nil {
 		return
 	}
-	fmt.Println("biome bpe", bitsPerEntry)
 	switch bitsPerEntry {
 	case 0:
 		biomes, err = UnpackSingleValuePalette(r, BiomesPerChunkSection)
@@ -132,9 +128,18 @@ func UnpackSection(r io.Reader) (blocks, biomes []int32, err error) {
 		return
 	}
 	biomes, err = UnpackBiomeData(r)
-	if err != nil {
 	return
 }
 
+func UnpackNSections(r io.Reader, n int) (blocks, biomes [][]int32, err error) {
+	for range n {
+		var blocksSection, biomesSections []int32
+		blocksSection, biomesSections, err = UnpackSection(r)
+		if err != nil {
+			return
+		}
+		blocks = append(blocks, blocksSection)
+		biomes = append(biomes, biomesSections)
+	}
 	return
 }

level/structure.go

@@ -0,0 +1,44 @@
+package level
+
+import (
+	"github.com/admin-else/strom/nbt"
+	"github.com/go-viper/mapstructure/v2"
+)
+
+func LoadStructure(fileName string) (s *Structure, err error) {
+	n, err := nbt.ReadFilePath(fileName)
+	if err != nil {
+		return
+	}
+	s = &Structure{}
+	err = mapstructure.Decode(n.Value, s)
+	return
+}
+
+type Structure struct {
+	DataVersion int32
+	Blocks      []struct {
+		Pos   [3]int32
+		State int
+	}
+	Palette []struct {
+		Name       string
+		Properties map[string]string
+	}
+	Size [3]int32
+}
+
+func (s *Structure) GetBlock(x, y, z int32) (name string) {
+	for _, block := range s.Blocks {
+		if block.Pos[0] == x && block.Pos[1] == y && block.Pos[2] == z {
+			palletIndex := block.State
+
+			if palletIndex >= len(s.Palette) {
+				return ""
+			}
+
+			return s.Palette[palletIndex].Name
+		}
+	}
+	return ""
+}

nbt/file.go

@@ -3,6 +3,7 @@ package nbt
 import (
 	"compress/gzip"
 	"io"
+	"os"
 )
 
 func WriteFile(file io.Writer, n Tag) (err error) {
@@ -22,3 +23,12 @@ func ReadFile(file io.Reader) (n *Tag, err error) {
 	err = n.Decode(r)
 	return
 }
+
+func ReadFilePath(path string) (n *Tag, err error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	return ReadFile(f)
+}

proto/connection.go

@@ -165,9 +165,9 @@ func (c *Conn) ActivateReceiveRoutine() {
 	if c.receiveRoutine {
 		return
 	}
-	c.receiveRoutine = true
 	c.packetCh = make(chan proto_base.EncodeDecodeAble, 100) // i dunno how many to buffer 100 seems reasonable
 	go c.ReceiveJob()
+	c.receiveRoutine = true
 }
 
 func (c *Conn) translatePacketVersion(packet proto_base.EncodeDecodeAble, packetInfo proto_base.PacketInfo) (convertedPacket proto_base.EncodeDecodeAble, err error) {