167 lines
3.1 KiB
Go
167 lines
3.1 KiB
Go
package fastnbt
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"math"
|
|
|
|
"github.com/Tnze/go-mc/nbt"
|
|
)
|
|
|
|
type Value struct {
|
|
comp Compound
|
|
list []*Value
|
|
data []byte
|
|
tag byte // nbt.Tag*
|
|
}
|
|
|
|
func NewBoolean(v bool) *Value {
|
|
data := byte(0)
|
|
if v {
|
|
data = 1
|
|
}
|
|
return &Value{tag: nbt.TagByte, data: []byte{data}}
|
|
}
|
|
|
|
func NewByte(v int8) *Value {
|
|
return &Value{tag: nbt.TagByte, data: []byte{byte(v)}}
|
|
}
|
|
|
|
func NewShort(v int16) *Value {
|
|
data := make([]byte, 2)
|
|
binary.BigEndian.PutUint16(data, uint16(v))
|
|
return &Value{tag: nbt.TagShort, data: data}
|
|
}
|
|
|
|
func NewInt(v int32) *Value {
|
|
data := make([]byte, 4)
|
|
binary.BigEndian.PutUint32(data, uint32(v))
|
|
return &Value{tag: nbt.TagInt, data: data}
|
|
}
|
|
|
|
func NewLong(v int64) *Value {
|
|
data := make([]byte, 8)
|
|
binary.BigEndian.PutUint64(data, uint64(v))
|
|
return &Value{tag: nbt.TagLong, data: data}
|
|
}
|
|
|
|
func NewFloat(f float32) *Value {
|
|
data := make([]byte, 4)
|
|
binary.BigEndian.PutUint32(data, math.Float32bits(f))
|
|
return &Value{tag: nbt.TagFloat, data: data}
|
|
}
|
|
|
|
func NewDouble(d float64) *Value {
|
|
data := make([]byte, 8)
|
|
binary.BigEndian.PutUint64(data, math.Float64bits(d))
|
|
return &Value{tag: nbt.TagDouble, data: data}
|
|
}
|
|
|
|
func NewByteArray(v []byte) *Value {
|
|
data := make([]byte, 4, 4+len(v))
|
|
binary.BigEndian.PutUint32(data, uint32(len(v)))
|
|
return &Value{tag: nbt.TagByteArray, data: append(data, v...)}
|
|
}
|
|
|
|
func NewString(str string) *Value {
|
|
data := make([]byte, 2, 2+len(str))
|
|
binary.BigEndian.PutUint16(data, uint16(len(str)))
|
|
return &Value{tag: nbt.TagString, data: append(data, str...)}
|
|
}
|
|
|
|
func NewList(elems ...*Value) *Value {
|
|
return &Value{tag: nbt.TagList, list: elems}
|
|
}
|
|
|
|
func NewCompound() *Value {
|
|
return &Value{tag: nbt.TagCompound}
|
|
}
|
|
|
|
func (v *Value) Boolean() bool {
|
|
if v.tag != nbt.TagByte {
|
|
return false
|
|
}
|
|
return v.data[0] != 0
|
|
}
|
|
|
|
func (v *Value) Byte() int8 {
|
|
if v.tag != nbt.TagByte {
|
|
return 0
|
|
}
|
|
return int8(v.data[0])
|
|
}
|
|
|
|
func (v *Value) Short() int16 {
|
|
if v.tag != nbt.TagShort {
|
|
return 0
|
|
}
|
|
return int16(binary.BigEndian.Uint16(v.data))
|
|
}
|
|
|
|
func (v *Value) Int() int32 {
|
|
if v.tag != nbt.TagInt {
|
|
return 0
|
|
}
|
|
return int32(binary.BigEndian.Uint32(v.data))
|
|
}
|
|
|
|
func (v *Value) Long() int64 {
|
|
if v.tag != nbt.TagLong {
|
|
return 0
|
|
}
|
|
return int64(binary.BigEndian.Uint64(v.data))
|
|
}
|
|
|
|
func (v *Value) Float() float32 {
|
|
if v.tag != nbt.TagFloat {
|
|
return float32(math.NaN())
|
|
}
|
|
return math.Float32frombits(binary.BigEndian.Uint32(v.data))
|
|
}
|
|
|
|
func (v *Value) Double() float64 {
|
|
if v.tag != nbt.TagDouble {
|
|
return math.NaN()
|
|
}
|
|
return math.Float64frombits(binary.BigEndian.Uint64(v.data))
|
|
}
|
|
|
|
func (v *Value) List() []*Value {
|
|
return v.list
|
|
}
|
|
|
|
func (v *Value) Compound() *Compound {
|
|
return &v.comp
|
|
}
|
|
|
|
func (v *Value) ByteArray() []byte {
|
|
if v.tag != nbt.TagByteArray {
|
|
return nil
|
|
}
|
|
return v.data[4:]
|
|
}
|
|
|
|
func (v *Value) IntArray() []int32 {
|
|
length := binary.BigEndian.Uint32(v.data)
|
|
ret := make([]int32, length)
|
|
for i := uint32(0); i < length; i += 4 {
|
|
ret[i] = int32(binary.BigEndian.Uint32(v.data[i:]))
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (v *Value) String() string {
|
|
if v.tag != nbt.TagString {
|
|
return ""
|
|
}
|
|
return string(v.data[2:])
|
|
}
|
|
|
|
type Compound struct {
|
|
kvs []kv
|
|
}
|
|
|
|
type kv struct {
|
|
tag string
|
|
v *Value
|
|
}
|