131 lines
3.0 KiB
Go
131 lines
3.0 KiB
Go
package save
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
)
|
|
|
|
const indexOutOfBounds = "index out of bounds"
|
|
const valueOutOfBounds = "value out of bounds"
|
|
|
|
// BitStorage implement the compacted data array used in chunk storage and heightmaps.
|
|
// You can think of this as a []intN whose N is called "bits" in NewBitStorage.
|
|
// For more info, see: https://wiki.vg/Chunk_Format
|
|
// This is implementation of the format since Minecraft 1.16
|
|
type BitStorage struct {
|
|
data []uint64
|
|
mask uint64
|
|
|
|
bits, length int
|
|
valuesPerLong int
|
|
}
|
|
|
|
// NewBitStorage create a new BitStorage. Return nil if bits == 0.
|
|
//
|
|
// The "bits" is the number of bits per value, which can be calculated by math/bits.Len()
|
|
// The "length" is the number of values.
|
|
// The "data" is optional for initializing. Panic if data != nil && len(data) != BitStorageSize(bits, length).
|
|
func NewBitStorage(bits, length int, data []uint64) (b *BitStorage) {
|
|
if bits == 0 {
|
|
return nil
|
|
}
|
|
|
|
b = &BitStorage{
|
|
mask: 1<<bits - 1,
|
|
bits: bits,
|
|
length: length,
|
|
valuesPerLong: 64 / bits,
|
|
}
|
|
dataLen := BitStorageSize(bits, length)
|
|
if data != nil {
|
|
if len(data) != dataLen {
|
|
panic(newBitStorageErr{ArrlLen: len(data), WantLen: dataLen})
|
|
}
|
|
b.data = data
|
|
} else {
|
|
b.data = make([]uint64, dataLen)
|
|
}
|
|
return
|
|
}
|
|
|
|
// BitStorageSize calculate how many uint64 is needed for given bits and length.
|
|
func BitStorageSize(bits, length int) (size int) {
|
|
if bits == 0 {
|
|
return 0
|
|
}
|
|
valuesPerLong := 64 / bits
|
|
return (length + valuesPerLong - 1) / valuesPerLong
|
|
}
|
|
|
|
type newBitStorageErr struct {
|
|
ArrlLen int
|
|
WantLen int
|
|
}
|
|
|
|
func (i newBitStorageErr) Error() string {
|
|
return fmt.Sprintf("invalid length given for storage, got: %d but expected: %d", i.ArrlLen, i.WantLen)
|
|
}
|
|
|
|
func (b *BitStorage) calcIndex(n int) (c, o int) {
|
|
c = n / b.valuesPerLong
|
|
o = (n - c*b.valuesPerLong) * b.bits
|
|
return
|
|
}
|
|
|
|
// Swap sets v into [i], and return the previous [i] value.
|
|
func (b *BitStorage) Swap(i, v int) (old int) {
|
|
if b == nil || i < 0 || i > b.length-1 {
|
|
panic(indexOutOfBounds)
|
|
}
|
|
if v < 0 || uint64(v) > b.mask {
|
|
panic(valueOutOfBounds)
|
|
}
|
|
|
|
c, offset := b.calcIndex(i)
|
|
l := b.data[c]
|
|
old = int(l >> offset & b.mask)
|
|
b.data[c] = l&(b.mask<<offset^math.MaxUint64) | (uint64(v)&b.mask)<<offset
|
|
return
|
|
}
|
|
|
|
// Set sets v into [i].
|
|
func (b *BitStorage) Set(i, v int) {
|
|
if b == nil || i < 0 || i > b.length-1 {
|
|
panic(indexOutOfBounds)
|
|
}
|
|
if v < 0 || uint64(v) > b.mask {
|
|
panic(valueOutOfBounds)
|
|
}
|
|
|
|
c, offset := b.calcIndex(i)
|
|
l := b.data[c]
|
|
b.data[c] = l&(b.mask<<offset^math.MaxUint64) | (uint64(v)&b.mask)<<offset
|
|
}
|
|
|
|
// Get gets [i] value.
|
|
func (b *BitStorage) Get(i int) int {
|
|
if b == nil || i < 0 || i > b.length-1 {
|
|
panic(indexOutOfBounds)
|
|
}
|
|
|
|
c, offset := b.calcIndex(i)
|
|
l := b.data[c]
|
|
return int(l >> offset & b.mask)
|
|
}
|
|
|
|
// Len is the number of stored values.
|
|
func (b *BitStorage) Len() int {
|
|
if b == nil {
|
|
return 0
|
|
}
|
|
return b.length
|
|
}
|
|
|
|
// Longs return the underling array of uint64 for encoding/decoding.
|
|
func (b *BitStorage) Longs() []uint64 {
|
|
if b == nil {
|
|
return []uint64{}
|
|
}
|
|
return b.data
|
|
}
|