146 lines
3.4 KiB
Go
146 lines
3.4 KiB
Go
package level
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"io"
|
|
"math"
|
|
|
|
"github.com/admin-else/strom/proto_base"
|
|
)
|
|
|
|
const (
|
|
BlocksPerChunkSection = 4096
|
|
BiomesPerChunkSection = 64
|
|
)
|
|
|
|
func UnpackArrayPalette(r io.Reader, bitsPerEntry uint8, numberOfEntries int) (data []int32, err error) {
|
|
palletLen, err := proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var pallet []int32 // remember we can't use make because this is user-controlled data
|
|
for range palletLen {
|
|
var entry int32
|
|
entry, err = proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
pallet = append(pallet, entry)
|
|
}
|
|
data, err = UnpackLongData(r, bitsPerEntry, numberOfEntries)
|
|
for i, b := range data {
|
|
data[i] = pallet[b] // maybe check bounds?
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func UnpackLongData(r io.Reader, bitsPerEntry uint8, numberOfEntries int) (data []int32, err error) {
|
|
entriesPerLong := int(64 / bitsPerEntry)
|
|
numberOfLongs := int(math.Ceil(float64(numberOfEntries) / float64(entriesPerLong)))
|
|
var dataL []uint64
|
|
for range numberOfLongs {
|
|
var entry uint64
|
|
err = binary.Read(r, binary.BigEndian, &entry)
|
|
if err != nil {
|
|
return
|
|
}
|
|
dataL = append(dataL, entry)
|
|
}
|
|
|
|
data = LongsToData(dataL, int32(numberOfEntries), int32(bitsPerEntry))
|
|
return
|
|
}
|
|
|
|
func UnpackSingleValuePalette(r io.Reader, numberOfEntries int) (data []int32, err error) {
|
|
entry, err := proto_base.DecodeVarInt(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
data = make([]int32, numberOfEntries)
|
|
for i := range data {
|
|
data[i] = entry
|
|
}
|
|
return
|
|
}
|
|
|
|
func LongsToData(data []uint64, n, bpe int32) (ret []int32) {
|
|
mask := (uint64(1) << uint32(bpe)) - 1
|
|
elementsPerLong := 64 / bpe
|
|
|
|
ret = make([]int32, n)
|
|
for i := range n {
|
|
ret[i] = int32((data[i/elementsPerLong] >> ((i % elementsPerLong) * bpe)) & mask)
|
|
}
|
|
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
|
|
}
|
|
switch bitsPerEntry {
|
|
case 0:
|
|
blocks, err = UnpackSingleValuePalette(r, BlocksPerChunkSection)
|
|
case 1, 2, 3, 4, 5, 6, 7, 8:
|
|
blocks, err = UnpackArrayPalette(r, bitsPerEntry, BlocksPerChunkSection)
|
|
default:
|
|
blocks, err = UnpackLongData(r, bitsPerEntry, BlocksPerChunkSection)
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func UnpackBiomeData(r io.Reader) (biomes []int32, err error) {
|
|
// net.minecraft.world.chunk.PaletteProvider#forBiomes
|
|
var bitsPerEntry uint8
|
|
err = binary.Read(r, binary.BigEndian, &bitsPerEntry)
|
|
if err != nil {
|
|
return
|
|
}
|
|
switch bitsPerEntry {
|
|
case 0:
|
|
biomes, err = UnpackSingleValuePalette(r, BiomesPerChunkSection)
|
|
case 1, 2, 3:
|
|
biomes, err = UnpackArrayPalette(r, bitsPerEntry, BiomesPerChunkSection)
|
|
default:
|
|
biomes, err = UnpackLongData(r, bitsPerEntry, BiomesPerChunkSection)
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func UnpackSection(r io.Reader) (blocks, biomes []int32, err error) {
|
|
var blockCount int16
|
|
err = binary.Read(r, binary.BigEndian, &blockCount)
|
|
if err != nil {
|
|
return
|
|
}
|
|
blocks, err = UnpackBlockData(r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
biomes, err = UnpackBiomeData(r)
|
|
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
|
|
}
|