_, err := w.Write(buf)
chk(err)
}
+
func readBuf(r io.Reader, n int) []byte {
buf := make([]byte, n)
_, err := io.ReadFull(r, buf)
} else {
write8(w, 0)
}
+
}
}); err != nil && err != io.EOF {
chk(err)
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}); err != nil && err != io.EOF {
chk(err)
Pos PlayerPos
}))(obj)).Pointed
chk(writePointedThing(w, x))
+
}
{
buf := w
*p, err = readPointedThing(r)
chk(err)
}
+
}
if r.N > 0 {
chk(fmt.Errorf("%d bytes of trailing data", r.N))
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
SudoAuthMethods AuthMethods
}))(obj)).MapSeed
write64(w, uint64(x))
+
}
{
x := (*(*(struct {
SudoAuthMethods AuthMethods
}))(obj)).MapSeed
*p = read64(r)
+
}
{
p := &(*(*(struct {
} else {
write8(w, 0)
}
+
}
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
}
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
if len(((*(*(struct {
//mt:const uint16(sha1.Size)
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
var local74 uint32
{
Timestamp int64 // Unix time.
}))(obj)).Timestamp
write64(w, uint64(x))
+
}
}
Timestamp int64 // Unix time.
}))(obj)).Timestamp
*p = int64(read64(r))
+
}
}
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
} else {
write8(w, 0)
}
+
}
if len(([]byte(*(*string)(&((*(*(struct {
Pos, Vel, Acc [3]float32
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
var local154 []uint8
var local155 uint32
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
if len(([]byte(*(*string)(&((*(*(struct {
Amount uint16
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
var local172 []uint8
var local173 uint32
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
Indoor color.NRGBA
}))(obj)).BgColor
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
if len(([]byte((*(*(struct {
BgColor color.NRGBA
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).SunFogTint
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).MoonFogTint
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
if len(([]byte((*(*(struct {
BgColor color.NRGBA
Indoor color.NRGBA
}))(obj)).DaySky
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).DayHorizon
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).DawnSky
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).DawnHorizon
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).NightSky
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).NightHorizon
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Indoor color.NRGBA
}))(obj)).Indoor
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
}
}
Indoor color.NRGBA
}))(obj)).BgColor
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
var local194 []uint8
var local195 uint16
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).SunFogTint
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).MoonFogTint
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
var local196 []uint8
var local197 uint16
Indoor color.NRGBA
}))(obj)).DaySky
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).DayHorizon
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).DawnSky
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).DawnHorizon
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).NightSky
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).NightHorizon
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Indoor color.NRGBA
}))(obj)).Indoor
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
}
}
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
Speed [2]float32
}))(obj)).DiffuseColor
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Speed [2]float32
}))(obj)).AmbientColor
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
Speed [2]float32
}))(obj)).DiffuseColor
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
Speed [2]float32
}))(obj)).AmbientColor
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
}))(obj)).Changed
{
w := zlib.NewWriter(w)
+
if x == nil {
write8(w, 0)
} else {
}
sort.Slice(keys, func(i, j int) bool {
p, q := keys[i], keys[j]
+
for i := range p {
switch {
case p[i] < q[i]:
return false
}
}
+
return false
})
for _, key := range keys {
chk(serialize(w, x[key]))
}
}
+
chk(w.Close())
}
+
}
{
buf := w
{
r, err := zlib.NewReader(byteReader{r})
chk(err)
+
switch ver := read8(r); ver {
case 0:
*p = nil
default:
chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
}
+
chk(r.Close())
}
+
}
if r.N > 0 {
chk(fmt.Errorf("%d bytes of trailing data", r.N))
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
Size float32
}))(obj)).Color
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
Size float32
}))(obj)).Color
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
AlphaUse
}))(obj)).Color
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
if err := pcall(func() {
((*(*(struct {
AlphaUse
}))(obj)).InsideTint
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if len(([]byte((*(*(struct {
Param0 Content
AlphaUse
}))(obj)).Color
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
if err := pcall(func() {
((*(*(struct {
AlphaUse
}))(obj)).InsideTint
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
var local269 []uint8
var local270 uint16
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
}
}
{
- w := zlib.NewWriter(w)
+ w := zstd.NewWriter(w)
for local285 := range (*(*(struct {
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
}))(obj)).NodeMetas
{
w := zlib.NewWriter(w)
+
if x == nil {
write8(w, 0)
} else {
i2pos := func(i int) [3]int16 {
return Blkpos2Pos([3]int16{}, keys[i])
}
+
p, q := i2pos(i), i2pos(j)
+
for i := range p {
switch {
case p[i] < q[i]:
return false
}
}
+
return false
})
for _, key := range keys {
chk(serialize(w, x[key]))
}
}
+
chk(w.Close())
}
+
}
{
local286 := uint8(2) // version
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
}
}
{
- r, err := zlib.NewReader(byteReader{r})
+ r, err := zstd.NewReader(byteReader{r})
chk(err)
for local291 := range (*(*(struct {
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
Flags MapBlkFlags
LitFrom LitFromBlks
- //mt:zlib
+ //mt:zstd
Param0 [4096]Content
Param1 [4096]uint8
Param2 [4096]uint8
{
r, err := zlib.NewReader(byteReader{r})
chk(err)
+
switch ver := read8(r); ver {
case 0:
*p = nil
default:
chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
}
+
chk(r.Close())
}
+
}
{
var local292 uint8
{
x := *(*(uint64))(obj)
write64(w, uint64(x))
+
}
}
{
p := &*(*(uint64))(obj)
*p = read64(r)
+
}
}
Msg AOMsg
}))(obj)).Msg
writeAOMsg(w, x)
+
}
{
buf := w
*p, err = readAOMsg(r)
chk(err)
}
+
}
if r.N > 0 {
chk(fmt.Errorf("%d bytes of trailing data", r.N))
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
ShortDesc string
}))(obj)).Color
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
ShortDesc string
}))(obj)).Color
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if len(([]byte((*(*(struct {
MaxHP uint16 // Player only.
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
NametagBG color.NRGBA
}))(obj)).Colors)[local340]
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
}
{
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if len(([]byte((*(*(struct {
MaxHP uint16 // Player only.
NametagBG color.NRGBA
}))(obj)).NametagColor
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
NametagBG color.NRGBA
}))(obj)).NametagBG
w.Write([]byte{x.A, x.R, x.G, x.B})
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
var local343 []uint8
var local344 uint16
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
NametagBG color.NRGBA
}))(obj)).Colors)[local353]
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
}
{
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
var local354 []uint8
var local355 uint16
NametagBG color.NRGBA
}))(obj)).NametagColor
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
NametagBG color.NRGBA
}))(obj)).NametagBG
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
+
}
}
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
{
x := (*(*(struct {
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
{
p := &(*(*(struct {
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
} else {
write8(w, 0)
}
+
}
if err := pcall(func() {
((*(*(struct {
chk(err)
}
}
+
}
}
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
if err := pcall(func() {
((*(*(struct {
}
}
}
+
}
}
} else {
write8(w, 0)
}
+
}
}
{
default:
chk(fmt.Errorf("invalid bool: %d", n))
}
+
}
}
{