import (
"bytes"
"compress/zlib"
- "crypto/sha1"
"errors"
"fmt"
"image/color"
}
func (obj *ToCltMediaPush) serialize(w io.Writer) {
+ if len(([]byte((*(*(struct {
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
+ }))(obj)).RawHash))) > math.MaxUint16 {
+ chk(ErrTooLong)
+ }
{
- local69 := uint16(sha1.Size)
- {
- x := local69
- write16(w, uint16(x))
- }
+ x := uint16(len(([]byte((*(*(struct {
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
+ }))(obj)).RawHash))))
+ write16(w, uint16(x))
}
{
- _, err := w.Write(((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).SHA1)[:])
+ _, err := w.Write(([]byte((*(*(struct {
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
+ }))(obj)).RawHash))[:])
chk(err)
}
if len(([]byte((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
}))(obj)).Filename))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
x := uint16(len(([]byte((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
}))(obj)).Filename))))
write16(w, uint16(x))
}
{
_, err := w.Write(([]byte((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
}))(obj)).Filename))[:])
chk(err)
}
{
x := (*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
+ }))(obj)).CallbackToken
+ write32(w, uint32(x))
+ }
+ {
+ x := (*(*(struct {
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
}))(obj)).ShouldCache
if x {
write8(w, 1)
}
}
- if len(((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).Data)) > math.MaxUint32 {
- chk(ErrTooLong)
- }
- {
- x := uint32(len(((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).Data)))
- write32(w, uint32(x))
- }
- {
- _, err := w.Write(((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).Data)[:])
- chk(err)
- }
}
func (obj *ToCltMediaPush) deserialize(r io.Reader) {
+ var local69 []uint8
+ var local70 uint16
{
- var local70 uint16
- local71 := uint16(sha1.Size)
- {
- p := &local70
- *p = read16(r)
- }
- if local70 != local71 {
- chk(fmt.Errorf("const %v: %v", "uint16(sha1.Size)", local70))
- }
+ p := &local70
+ *p = read16(r)
}
+ (local69) = make([]uint8, local70)
{
- _, err := io.ReadFull(r, ((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).SHA1)[:])
+ _, err := io.ReadFull(r, (local69)[:])
chk(err)
}
- var local72 []uint8
- var local73 uint16
- {
- p := &local73
+ ((*(*(struct {
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
+ }))(obj)).RawHash) = string(local69)
+ var local71 []uint8
+ var local72 uint16
+ {
+ p := &local72
*p = read16(r)
}
- (local72) = make([]uint8, local73)
+ (local71) = make([]uint8, local72)
{
- _, err := io.ReadFull(r, (local72)[:])
+ _, err := io.ReadFull(r, (local71)[:])
chk(err)
}
((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).Filename) = string(local72)
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
+ }))(obj)).Filename) = string(local71)
{
p := &(*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
+ }))(obj)).CallbackToken
+ *p = read32(r)
+ }
+ {
+ p := &(*(*(struct {
+ RawHash string
+ Filename string
+ CallbackToken uint32
+ ShouldCache bool
}))(obj)).ShouldCache
switch n := read8(r); n {
case 0:
}
}
- var local74 uint32
- {
- p := &local74
- *p = read32(r)
- }
- ((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).Data) = make([]byte, local74)
- {
- _, err := io.ReadFull(r, ((*(*(struct {
- //mt:const uint16(sha1.Size)
- SHA1 [sha1.Size]byte
- Filename string
- ShouldCache bool
-
- //mt:len32
- Data []byte
- }))(obj)).Data)[:])
- chk(err)
- }
}
func (obj *ToCltChatMsg) serialize(w io.Writer) {
{
- local75 := uint8(1)
+ local73 := uint8(1)
{
- x := local75
+ x := local73
write8(w, uint8(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
}
- local76 := utf16.Encode([]rune((*(*(struct {
+ local74 := utf16.Encode([]rune((*(*(struct {
Type ChatMsgType
//mt:utf16
Timestamp int64 // Unix time.
}))(obj)).Sender))
- if len((local76)) > math.MaxUint16 {
+ if len((local74)) > math.MaxUint16 {
chk(ErrTooLong)
}
{
- x := uint16(len((local76)))
+ x := uint16(len((local74)))
write16(w, uint16(x))
}
- for local77 := range local76 {
+ for local75 := range local74 {
{
- x := (local76)[local77]
+ x := (local74)[local75]
write16(w, uint16(x))
}
}
- local78 := utf16.Encode([]rune((*(*(struct {
+ local76 := utf16.Encode([]rune((*(*(struct {
Type ChatMsgType
//mt:utf16
Timestamp int64 // Unix time.
}))(obj)).Text))
- if len((local78)) > math.MaxUint16 {
+ if len((local76)) > math.MaxUint16 {
chk(ErrTooLong)
}
{
- x := uint16(len((local78)))
+ x := uint16(len((local76)))
write16(w, uint16(x))
}
- for local79 := range local78 {
+ for local77 := range local76 {
{
- x := (local78)[local79]
+ x := (local76)[local77]
write16(w, uint16(x))
}
}
func (obj *ToCltChatMsg) deserialize(r io.Reader) {
{
- var local80 uint8
- local81 := uint8(1)
+ var local78 uint8
+ local79 := uint8(1)
{
- p := &local80
+ p := &local78
*p = read8(r)
}
- if local80 != local81 {
- chk(fmt.Errorf("const %v: %v", "uint8(1)", local80))
+ if local78 != local79 {
+ chk(fmt.Errorf("const %v: %v", "uint8(1)", local78))
}
}
if err := pcall(func() {
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ChatMsgType", err))
}
- var local82 []uint16
- var local83 uint16
+ var local80 []uint16
+ var local81 uint16
{
- p := &local83
+ p := &local81
*p = read16(r)
}
- (local82) = make([]uint16, local83)
- for local84 := range local82 {
+ (local80) = make([]uint16, local81)
+ for local82 := range local80 {
{
- p := &(local82)[local84]
+ p := &(local80)[local82]
*p = read16(r)
}
}
Sender, Text string
Timestamp int64 // Unix time.
- }))(obj)).Sender = string(utf16.Decode(local82))
- var local85 []uint16
- var local86 uint16
+ }))(obj)).Sender = string(utf16.Decode(local80))
+ var local83 []uint16
+ var local84 uint16
{
- p := &local86
+ p := &local84
*p = read16(r)
}
- (local85) = make([]uint16, local86)
- for local87 := range local85 {
+ (local83) = make([]uint16, local84)
+ for local85 := range local83 {
{
- p := &(local85)[local87]
+ p := &(local83)[local85]
*p = read16(r)
}
}
Sender, Text string
Timestamp int64 // Unix time.
- }))(obj)).Text = string(utf16.Decode(local85))
+ }))(obj)).Text = string(utf16.Decode(local83))
{
p := &(*(*(struct {
Type ChatMsgType
}))(obj)).Remove)))
write16(w, uint16(x))
}
- for local88 := range (*(*(struct {
+ for local86 := range (*(*(struct {
Remove []AOID
Add []AOAdd
}))(obj)).Remove {
(((*(*(struct {
Remove []AOID
Add []AOAdd
- }))(obj)).Remove)[local88]).serialize(w)
+ }))(obj)).Remove)[local86]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Add)))
write16(w, uint16(x))
}
- for local89 := range (*(*(struct {
+ for local87 := range (*(*(struct {
Remove []AOID
Add []AOAdd
}))(obj)).Add {
(((*(*(struct {
Remove []AOID
Add []AOAdd
- }))(obj)).Add)[local89]).serialize(w)
+ }))(obj)).Add)[local87]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
- var local90 uint16
+ var local88 uint16
{
- p := &local90
+ p := &local88
*p = read16(r)
}
((*(*(struct {
Remove []AOID
Add []AOAdd
- }))(obj)).Remove) = make([]AOID, local90)
- for local91 := range (*(*(struct {
+ }))(obj)).Remove) = make([]AOID, local88)
+ for local89 := range (*(*(struct {
Remove []AOID
Add []AOAdd
}))(obj)).Remove {
(((*(*(struct {
Remove []AOID
Add []AOAdd
- }))(obj)).Remove)[local91]).deserialize(r)
+ }))(obj)).Remove)[local89]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
}
}
- var local92 uint16
+ var local90 uint16
{
- p := &local92
+ p := &local90
*p = read16(r)
}
((*(*(struct {
Remove []AOID
Add []AOAdd
- }))(obj)).Add) = make([]AOAdd, local92)
- for local93 := range (*(*(struct {
+ }))(obj)).Add) = make([]AOAdd, local90)
+ for local91 := range (*(*(struct {
Remove []AOID
Add []AOAdd
}))(obj)).Add {
(((*(*(struct {
Remove []AOID
Add []AOAdd
- }))(obj)).Add)[local93]).deserialize(r)
+ }))(obj)).Add)[local91]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *ToCltAOMsgs) serialize(w io.Writer) {
- for local94 := range (*(*(struct {
+ for local92 := range (*(*(struct {
//mt:raw
Msgs []IDAOMsg
}))(obj)).Msgs {
(((*(*(struct {
//mt:raw
Msgs []IDAOMsg
- }))(obj)).Msgs)[local94]).serialize(w)
+ }))(obj)).Msgs)[local92]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
for {
- var local95 IDAOMsg
+ var local93 IDAOMsg
err := pcall(func() {
if err := pcall(func() {
- (local95).deserialize(r)
+ (local93).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Msgs) = append(((*(*(struct {
//mt:raw
Msgs []IDAOMsg
- }))(obj)).Msgs), local95)
+ }))(obj)).Msgs), local93)
chk(err)
}
}
}
func (obj *ToCltLegacyKick) serialize(w io.Writer) {
- local96 := utf16.Encode([]rune((*(*(struct {
+ local94 := utf16.Encode([]rune((*(*(struct {
//mt:utf16
Reason string
}))(obj)).Reason))
- if len((local96)) > math.MaxUint16 {
+ if len((local94)) > math.MaxUint16 {
chk(ErrTooLong)
}
{
- x := uint16(len((local96)))
+ x := uint16(len((local94)))
write16(w, uint16(x))
}
- for local97 := range local96 {
+ for local95 := range local94 {
{
- x := (local96)[local97]
+ x := (local94)[local95]
write16(w, uint16(x))
}
}
}
func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
- var local98 []uint16
- var local99 uint16
+ var local96 []uint16
+ var local97 uint16
{
- p := &local99
+ p := &local97
*p = read16(r)
}
- (local98) = make([]uint16, local99)
- for local100 := range local98 {
+ (local96) = make([]uint16, local97)
+ for local98 := range local96 {
{
- p := &(local98)[local100]
+ p := &(local96)[local98]
*p = read16(r)
}
}
(*(*(struct {
//mt:utf16
Reason string
- }))(obj)).Reason = string(utf16.Decode(local98))
+ }))(obj)).Reason = string(utf16.Decode(local96))
}
func (obj *ToCltFOV) serialize(w io.Writer) {
}))(obj)).Files)))
write32(w, uint32(x))
}
- for local101 := range (*(*(struct {
+ for local99 := range (*(*(struct {
// N is the total number of ToCltMedia packets.
// I is the index of this packet.
N, I uint16
//mt:len32
Data []byte
}
- }))(obj)).Files)[local101]).Name))) > math.MaxUint16 {
+ }))(obj)).Files)[local99]).Name))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
//mt:len32
Data []byte
}
- }))(obj)).Files)[local101]).Name))))
+ }))(obj)).Files)[local99]).Name))))
write16(w, uint16(x))
}
{
//mt:len32
Data []byte
}
- }))(obj)).Files)[local101]).Name))[:])
+ }))(obj)).Files)[local99]).Name))[:])
chk(err)
}
if len(((((*(*(struct {
//mt:len32
Data []byte
}
- }))(obj)).Files)[local101]).Data)) > math.MaxUint32 {
+ }))(obj)).Files)[local99]).Data)) > math.MaxUint32 {
chk(ErrTooLong)
}
{
//mt:len32
Data []byte
}
- }))(obj)).Files)[local101]).Data)))
+ }))(obj)).Files)[local99]).Data)))
write32(w, uint32(x))
}
{
//mt:len32
Data []byte
}
- }))(obj)).Files)[local101]).Data)[:])
+ }))(obj)).Files)[local99]).Data)[:])
chk(err)
}
}
}))(obj)).I
*p = read16(r)
}
- var local102 uint32
+ var local100 uint32
{
- p := &local102
+ p := &local100
*p = read32(r)
}
((*(*(struct {
}))(obj)).Files) = make([]struct {
Name string
Data []byte
- }, local102)
- for local103 := range (*(*(struct {
+ }, local100)
+ for local101 := range (*(*(struct {
// N is the total number of ToCltMedia packets.
// I is the index of this packet.
N, I uint16
Data []byte
}
}))(obj)).Files {
- var local104 []uint8
- var local105 uint16
+ var local102 []uint8
+ var local103 uint16
{
- p := &local105
+ p := &local103
*p = read16(r)
}
- (local104) = make([]uint8, local105)
+ (local102) = make([]uint8, local103)
{
- _, err := io.ReadFull(r, (local104)[:])
+ _, err := io.ReadFull(r, (local102)[:])
chk(err)
}
((((*(*(struct {
//mt:len32
Data []byte
}
- }))(obj)).Files)[local103]).Name) = string(local104)
- var local106 uint32
+ }))(obj)).Files)[local101]).Name) = string(local102)
+ var local104 uint32
{
- p := &local106
+ p := &local104
*p = read32(r)
}
((((*(*(struct {
//mt:len32
Data []byte
}
- }))(obj)).Files)[local103]).Data) = make([]byte, local106)
+ }))(obj)).Files)[local101]).Data) = make([]byte, local104)
{
_, err := io.ReadFull(r, ((((*(*(struct {
// N is the total number of ToCltMedia packets.
//mt:len32
Data []byte
}
- }))(obj)).Files)[local103]).Data)[:])
+ }))(obj)).Files)[local101]).Data)[:])
chk(err)
}
}
{
w := zlib.NewWriter(w)
{
- local107 := uint8(1)
+ local105 := uint8(1)
{
- x := local107
+ x := local105
write8(w, uint8(x))
}
}
r, err := zlib.NewReader(byteReader{r})
chk(err)
{
- var local108 uint8
- local109 := uint8(1)
+ var local106 uint8
+ local107 := uint8(1)
{
- p := &local108
+ p := &local106
*p = read8(r)
}
- if local108 != local109 {
- chk(fmt.Errorf("const %v: %v", "uint8(1)", local108))
+ if local106 != local107 {
+ chk(fmt.Errorf("const %v: %v", "uint8(1)", local106))
}
}
{
}))(obj)).Files)))
write16(w, uint16(x))
}
- for local110 := range (*(*(struct {
+ for local108 := range (*(*(struct {
Files []struct {
Name string
Base64SHA1 string
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local110]).Name))) > math.MaxUint16 {
+ }))(obj)).Files)[local108]).Name))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local110]).Name))))
+ }))(obj)).Files)[local108]).Name))))
write16(w, uint16(x))
}
{
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local110]).Name))[:])
+ }))(obj)).Files)[local108]).Name))[:])
chk(err)
}
if len(([]byte((((*(*(struct {
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local110]).Base64SHA1))) > math.MaxUint16 {
+ }))(obj)).Files)[local108]).Base64SHA1))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local110]).Base64SHA1))))
+ }))(obj)).Files)[local108]).Base64SHA1))))
write16(w, uint16(x))
}
{
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local110]).Base64SHA1))[:])
+ }))(obj)).Files)[local108]).Base64SHA1))[:])
chk(err)
}
}
}
func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
- var local111 uint16
+ var local109 uint16
{
- p := &local111
+ p := &local109
*p = read16(r)
}
((*(*(struct {
}))(obj)).Files) = make([]struct {
Name string
Base64SHA1 string
- }, local111)
- for local112 := range (*(*(struct {
+ }, local109)
+ for local110 := range (*(*(struct {
Files []struct {
Name string
Base64SHA1 string
}
URL string
}))(obj)).Files {
- var local113 []uint8
- var local114 uint16
+ var local111 []uint8
+ var local112 uint16
{
- p := &local114
+ p := &local112
*p = read16(r)
}
- (local113) = make([]uint8, local114)
+ (local111) = make([]uint8, local112)
{
- _, err := io.ReadFull(r, (local113)[:])
+ _, err := io.ReadFull(r, (local111)[:])
chk(err)
}
((((*(*(struct {
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local112]).Name) = string(local113)
- var local115 []uint8
- var local116 uint16
+ }))(obj)).Files)[local110]).Name) = string(local111)
+ var local113 []uint8
+ var local114 uint16
{
- p := &local116
+ p := &local114
*p = read16(r)
}
- (local115) = make([]uint8, local116)
+ (local113) = make([]uint8, local114)
{
- _, err := io.ReadFull(r, (local115)[:])
+ _, err := io.ReadFull(r, (local113)[:])
chk(err)
}
((((*(*(struct {
Base64SHA1 string
}
URL string
- }))(obj)).Files)[local112]).Base64SHA1) = string(local115)
+ }))(obj)).Files)[local110]).Base64SHA1) = string(local113)
}
- var local117 []uint8
- var local118 uint16
+ var local115 []uint8
+ var local116 uint16
{
- p := &local118
+ p := &local116
*p = read16(r)
}
- (local117) = make([]uint8, local118)
+ (local115) = make([]uint8, local116)
{
- _, err := io.ReadFull(r, (local117)[:])
+ _, err := io.ReadFull(r, (local115)[:])
chk(err)
}
((*(*(struct {
Base64SHA1 string
}
URL string
- }))(obj)).URL) = string(local117)
+ }))(obj)).URL) = string(local115)
}
func (obj *ToCltItemDefs) serialize(w io.Writer) {
{
w := zlib.NewWriter(w)
{
- local119 := uint8(0)
+ local117 := uint8(0)
{
- x := local119
+ x := local117
write8(w, uint8(x))
}
}
}))(obj)).Defs)))
write16(w, uint16(x))
}
- for local120 := range (*(*(struct {
+ for local118 := range (*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
}))(obj)).Defs {
(((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Defs)[local120]).serialize(w)
+ }))(obj)).Defs)[local118]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Aliases)))
write16(w, uint16(x))
}
- for local121 := range (*(*(struct {
+ for local119 := range (*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
}))(obj)).Aliases {
if len(([]byte((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local121]).Alias))) > math.MaxUint16 {
+ }))(obj)).Aliases)[local119]).Alias))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
x := uint16(len(([]byte((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local121]).Alias))))
+ }))(obj)).Aliases)[local119]).Alias))))
write16(w, uint16(x))
}
{
_, err := w.Write(([]byte((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local121]).Alias))[:])
+ }))(obj)).Aliases)[local119]).Alias))[:])
chk(err)
}
if len(([]byte((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local121]).Orig))) > math.MaxUint16 {
+ }))(obj)).Aliases)[local119]).Orig))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
x := uint16(len(([]byte((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local121]).Orig))))
+ }))(obj)).Aliases)[local119]).Orig))))
write16(w, uint16(x))
}
{
_, err := w.Write(([]byte((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local121]).Orig))[:])
+ }))(obj)).Aliases)[local119]).Orig))[:])
chk(err)
}
}
r, err := zlib.NewReader(byteReader{r})
chk(err)
{
- var local122 uint8
- local123 := uint8(0)
+ var local120 uint8
+ local121 := uint8(0)
{
- p := &local122
+ p := &local120
*p = read8(r)
}
- if local122 != local123 {
- chk(fmt.Errorf("const %v: %v", "uint8(0)", local122))
+ if local120 != local121 {
+ chk(fmt.Errorf("const %v: %v", "uint8(0)", local120))
}
}
- var local124 uint16
+ var local122 uint16
{
- p := &local124
+ p := &local122
*p = read16(r)
}
((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Defs) = make([]ItemDef, local124)
- for local125 := range (*(*(struct {
+ }))(obj)).Defs) = make([]ItemDef, local122)
+ for local123 := range (*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
}))(obj)).Defs {
(((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Defs)[local125]).deserialize(r)
+ }))(obj)).Defs)[local123]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemDef", err))
}
}
- var local126 uint16
+ var local124 uint16
{
- p := &local126
+ p := &local124
*p = read16(r)
}
((*(*(struct {
}))(obj)).Aliases) = make([]struct {
Alias string
Orig string
- }, local126)
- for local127 := range (*(*(struct {
+ }, local124)
+ for local125 := range (*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
}))(obj)).Aliases {
- var local128 []uint8
- var local129 uint16
+ var local126 []uint8
+ var local127 uint16
{
- p := &local129
+ p := &local127
*p = read16(r)
}
- (local128) = make([]uint8, local129)
+ (local126) = make([]uint8, local127)
{
- _, err := io.ReadFull(r, (local128)[:])
+ _, err := io.ReadFull(r, (local126)[:])
chk(err)
}
((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local127]).Alias) = string(local128)
- var local130 []uint8
- var local131 uint16
+ }))(obj)).Aliases)[local125]).Alias) = string(local126)
+ var local128 []uint8
+ var local129 uint16
{
- p := &local131
+ p := &local129
*p = read16(r)
}
- (local130) = make([]uint8, local131)
+ (local128) = make([]uint8, local129)
{
- _, err := io.ReadFull(r, (local130)[:])
+ _, err := io.ReadFull(r, (local128)[:])
chk(err)
}
((((*(*(struct {
Defs []ItemDef
Aliases []struct{ Alias, Orig string }
- }))(obj)).Aliases)[local127]).Orig) = string(local130)
+ }))(obj)).Aliases)[local125]).Orig) = string(local128)
}
chk(r.Close())
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.SoundID", err))
}
- var local132 []uint8
- var local133 uint16
+ var local130 []uint8
+ var local131 uint16
{
- p := &local133
+ p := &local131
*p = read16(r)
}
- (local132) = make([]uint8, local133)
+ (local130) = make([]uint8, local131)
{
- _, err := io.ReadFull(r, (local132)[:])
+ _, err := io.ReadFull(r, (local130)[:])
chk(err)
}
((*(*(struct {
Fade float32
Pitch float32
Ephemeral bool
- }))(obj)).Name) = string(local132)
+ }))(obj)).Name) = string(local130)
{
p := &(*(*(struct {
ID SoundID
}))(obj)).Privs)))
write16(w, uint16(x))
}
- for local134 := range (*(*(struct {
+ for local132 := range (*(*(struct {
Privs []string
}))(obj)).Privs {
if len(([]byte(((*(*(struct {
Privs []string
- }))(obj)).Privs)[local134]))) > math.MaxUint16 {
+ }))(obj)).Privs)[local132]))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
x := uint16(len(([]byte(((*(*(struct {
Privs []string
- }))(obj)).Privs)[local134]))))
+ }))(obj)).Privs)[local132]))))
write16(w, uint16(x))
}
{
_, err := w.Write(([]byte(((*(*(struct {
Privs []string
- }))(obj)).Privs)[local134]))[:])
+ }))(obj)).Privs)[local132]))[:])
chk(err)
}
}
}
func (obj *ToCltPrivs) deserialize(r io.Reader) {
- var local135 uint16
+ var local133 uint16
{
- p := &local135
+ p := &local133
*p = read16(r)
}
((*(*(struct {
Privs []string
- }))(obj)).Privs) = make([]string, local135)
- for local136 := range (*(*(struct {
+ }))(obj)).Privs) = make([]string, local133)
+ for local134 := range (*(*(struct {
Privs []string
}))(obj)).Privs {
- var local137 []uint8
- var local138 uint16
+ var local135 []uint8
+ var local136 uint16
{
- p := &local138
+ p := &local136
*p = read16(r)
}
- (local137) = make([]uint8, local138)
+ (local135) = make([]uint8, local136)
{
- _, err := io.ReadFull(r, (local137)[:])
+ _, err := io.ReadFull(r, (local135)[:])
chk(err)
}
(((*(*(struct {
Privs []string
- }))(obj)).Privs)[local136]) = string(local137)
+ }))(obj)).Privs)[local134]) = string(local135)
}
}
}
func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
- var local139 []uint8
- var local140 uint32
+ var local137 []uint8
+ var local138 uint32
{
- p := &local140
+ p := &local138
*p = read32(r)
}
- (local139) = make([]uint8, local140)
+ (local137) = make([]uint8, local138)
{
- _, err := io.ReadFull(r, (local139)[:])
+ _, err := io.ReadFull(r, (local137)[:])
chk(err)
}
((*(*(struct {
//mt:len32
Formspec string
- }))(obj)).Formspec) = string(local139)
+ }))(obj)).Formspec) = string(local137)
}
func (obj *ToCltDetachedInv) serialize(w io.Writer) {
}
func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
- var local141 []uint8
- var local142 uint16
+ var local139 []uint8
+ var local140 uint16
{
- p := &local142
+ p := &local140
*p = read16(r)
}
- (local141) = make([]uint8, local142)
+ (local139) = make([]uint8, local140)
{
- _, err := io.ReadFull(r, (local141)[:])
+ _, err := io.ReadFull(r, (local139)[:])
chk(err)
}
((*(*(struct {
//mt:raw
Inv string
- }))(obj)).Name) = string(local141)
+ }))(obj)).Name) = string(local139)
{
p := &(*(*(struct {
Name string
}))(obj)).Len
*p = read16(r)
}
- var local143 []uint8
+ var local141 []uint8
{
var err error
- (local143), err = io.ReadAll(r)
+ (local141), err = io.ReadAll(r)
chk(err)
}
((*(*(struct {
//mt:raw
Inv string
- }))(obj)).Inv) = string(local143)
+ }))(obj)).Inv) = string(local141)
}
func (obj *ToCltShowFormspec) serialize(w io.Writer) {
}
func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
- var local144 []uint8
- var local145 uint32
+ var local142 []uint8
+ var local143 uint32
{
- p := &local145
+ p := &local143
*p = read32(r)
}
- (local144) = make([]uint8, local145)
+ (local142) = make([]uint8, local143)
{
- _, err := io.ReadFull(r, (local144)[:])
+ _, err := io.ReadFull(r, (local142)[:])
chk(err)
}
((*(*(struct {
Formspec string
Formname string
- }))(obj)).Formspec) = string(local144)
- var local146 []uint8
- var local147 uint16
+ }))(obj)).Formspec) = string(local142)
+ var local144 []uint8
+ var local145 uint16
{
- p := &local147
+ p := &local145
*p = read16(r)
}
- (local146) = make([]uint8, local147)
+ (local144) = make([]uint8, local145)
{
- _, err := io.ReadFull(r, (local146)[:])
+ _, err := io.ReadFull(r, (local144)[:])
chk(err)
}
((*(*(struct {
Formspec string
Formname string
- }))(obj)).Formname) = string(local146)
+ }))(obj)).Formname) = string(local144)
}
func (obj *ToCltMovement) serialize(w io.Writer) {
}
func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
- for local148 := range (*(*(struct {
+ for local146 := range (*(*(struct {
Pos, Vel, Acc [3]float32
ExpirationTime float32 // in seconds.
Size float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Pos)[local148]
+ }))(obj)).Pos)[local146]
write32(w, math.Float32bits(x))
}
}
- for local149 := range (*(*(struct {
+ for local147 := range (*(*(struct {
Pos, Vel, Acc [3]float32
ExpirationTime float32 // in seconds.
Size float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Vel)[local149]
+ }))(obj)).Vel)[local147]
write32(w, math.Float32bits(x))
}
}
- for local150 := range (*(*(struct {
+ for local148 := range (*(*(struct {
Pos, Vel, Acc [3]float32
ExpirationTime float32 // in seconds.
Size float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Acc)[local150]
+ }))(obj)).Acc)[local148]
write32(w, math.Float32bits(x))
}
}
}
func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
- for local151 := range (*(*(struct {
+ for local149 := range (*(*(struct {
Pos, Vel, Acc [3]float32
ExpirationTime float32 // in seconds.
Size float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Pos)[local151]
+ }))(obj)).Pos)[local149]
*p = math.Float32frombits(read32(r))
}
}
- for local152 := range (*(*(struct {
+ for local150 := range (*(*(struct {
Pos, Vel, Acc [3]float32
ExpirationTime float32 // in seconds.
Size float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Vel)[local152]
+ }))(obj)).Vel)[local150]
*p = math.Float32frombits(read32(r))
}
}
- for local153 := range (*(*(struct {
+ for local151 := range (*(*(struct {
Pos, Vel, Acc [3]float32
ExpirationTime float32 // in seconds.
Size float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Acc)[local153]
+ }))(obj)).Acc)[local151]
*p = math.Float32frombits(read32(r))
}
}
}
}
- var local154 []uint8
- var local155 uint32
+ var local152 []uint8
+ var local153 uint32
{
- p := &local155
+ p := &local153
*p = read32(r)
}
- (local154) = make([]uint8, local155)
+ (local152) = make([]uint8, local153)
{
- _, err := io.ReadFull(r, (local154)[:])
+ _, err := io.ReadFull(r, (local152)[:])
chk(err)
}
(*(*string)(&((*(*(struct {
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Texture))) = string(local154)
+ }))(obj)).Texture))) = string(local152)
{
p := &(*(*(struct {
Pos, Vel, Acc [3]float32
}))(obj)).Duration
write32(w, math.Float32bits(x))
}
- for local156 := range (*(*(struct {
+ for local154 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam2 uint8
NodeTile uint8
}))(obj)).Pos {
- for local157 := range ((*(*(struct {
+ for local155 := range ((*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Pos)[local156] {
+ }))(obj)).Pos)[local154] {
{
x := (((*(*(struct {
Amount uint16
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Pos)[local156])[local157]
+ }))(obj)).Pos)[local154])[local155]
write32(w, math.Float32bits(x))
}
}
}
- for local158 := range (*(*(struct {
+ for local156 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam2 uint8
NodeTile uint8
}))(obj)).Vel {
- for local159 := range ((*(*(struct {
+ for local157 := range ((*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Vel)[local158] {
+ }))(obj)).Vel)[local156] {
{
x := (((*(*(struct {
Amount uint16
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Vel)[local158])[local159]
+ }))(obj)).Vel)[local156])[local157]
write32(w, math.Float32bits(x))
}
}
}
- for local160 := range (*(*(struct {
+ for local158 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam2 uint8
NodeTile uint8
}))(obj)).Acc {
- for local161 := range ((*(*(struct {
+ for local159 := range ((*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Acc)[local160] {
+ }))(obj)).Acc)[local158] {
{
x := (((*(*(struct {
Amount uint16
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Acc)[local160])[local161]
+ }))(obj)).Acc)[local158])[local159]
write32(w, math.Float32bits(x))
}
}
}
- for local162 := range (*(*(struct {
+ for local160 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).ExpirationTime)[local162]
+ }))(obj)).ExpirationTime)[local160]
write32(w, math.Float32bits(x))
}
}
- for local163 := range (*(*(struct {
+ for local161 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Size)[local163]
+ }))(obj)).Size)[local161]
write32(w, math.Float32bits(x))
}
}
}))(obj)).Duration
*p = math.Float32frombits(read32(r))
}
- for local164 := range (*(*(struct {
+ for local162 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam2 uint8
NodeTile uint8
}))(obj)).Pos {
- for local165 := range ((*(*(struct {
+ for local163 := range ((*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Pos)[local164] {
+ }))(obj)).Pos)[local162] {
{
p := &(((*(*(struct {
Amount uint16
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Pos)[local164])[local165]
+ }))(obj)).Pos)[local162])[local163]
*p = math.Float32frombits(read32(r))
}
}
}
- for local166 := range (*(*(struct {
+ for local164 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam2 uint8
NodeTile uint8
}))(obj)).Vel {
- for local167 := range ((*(*(struct {
+ for local165 := range ((*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Vel)[local166] {
+ }))(obj)).Vel)[local164] {
{
p := &(((*(*(struct {
Amount uint16
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Vel)[local166])[local167]
+ }))(obj)).Vel)[local164])[local165]
*p = math.Float32frombits(read32(r))
}
}
}
- for local168 := range (*(*(struct {
+ for local166 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam2 uint8
NodeTile uint8
}))(obj)).Acc {
- for local169 := range ((*(*(struct {
+ for local167 := range ((*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Acc)[local168] {
+ }))(obj)).Acc)[local166] {
{
p := &(((*(*(struct {
Amount uint16
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Acc)[local168])[local169]
+ }))(obj)).Acc)[local166])[local167]
*p = math.Float32frombits(read32(r))
}
}
}
- for local170 := range (*(*(struct {
+ for local168 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).ExpirationTime)[local170]
+ }))(obj)).ExpirationTime)[local168]
*p = math.Float32frombits(read32(r))
}
}
- for local171 := range (*(*(struct {
+ for local169 := range (*(*(struct {
Amount uint16
Duration float32
Pos, Vel, Acc [2][3]float32
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Size)[local171]
+ }))(obj)).Size)[local169]
*p = math.Float32frombits(read32(r))
}
}
}
}
- var local172 []uint8
- var local173 uint32
+ var local170 []uint8
+ var local171 uint32
{
- p := &local173
+ p := &local171
*p = read32(r)
}
- (local172) = make([]uint8, local173)
+ (local170) = make([]uint8, local171)
{
- _, err := io.ReadFull(r, (local172)[:])
+ _, err := io.ReadFull(r, (local170)[:])
chk(err)
}
(*(*string)(&((*(*(struct {
NodeParam0 Content
NodeParam2 uint8
NodeTile uint8
- }))(obj)).Texture))) = string(local172)
+ }))(obj)).Texture))) = string(local170)
if err := pcall(func() {
((*(*(struct {
Amount uint16
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDPos {
- for local174 := range (*(*(struct {
+ for local172 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Pos)[local174]
+ }))(obj)).Pos)[local172]
write32(w, math.Float32bits(x))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDScale {
- for local175 := range (*(*(struct {
+ for local173 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Scale)[local175]
+ }))(obj)).Scale)[local173]
write32(w, math.Float32bits(x))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDAlign {
- for local176 := range (*(*(struct {
+ for local174 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Align)[local176]
+ }))(obj)).Align)[local174]
write32(w, math.Float32bits(x))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDOffset {
- for local177 := range (*(*(struct {
+ for local175 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Offset)[local177]
+ }))(obj)).Offset)[local175]
write32(w, math.Float32bits(x))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDSize {
- for local178 := range (*(*(struct {
+ for local176 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Size)[local178]
+ }))(obj)).Size)[local176]
write32(w, uint32(x))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDPos {
- for local179 := range (*(*(struct {
+ for local177 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Pos)[local179]
+ }))(obj)).Pos)[local177]
*p = math.Float32frombits(read32(r))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDName {
- var local180 []uint8
- var local181 uint16
+ var local178 []uint8
+ var local179 uint16
{
- p := &local181
+ p := &local179
*p = read16(r)
}
- (local180) = make([]uint8, local181)
+ (local178) = make([]uint8, local179)
{
- _, err := io.ReadFull(r, (local180)[:])
+ _, err := io.ReadFull(r, (local178)[:])
chk(err)
}
((*(*(struct {
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Name) = string(local180)
+ }))(obj)).Name) = string(local178)
}
if (*(*(struct {
ID HUDID
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDScale {
- for local182 := range (*(*(struct {
+ for local180 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Scale)[local182]
+ }))(obj)).Scale)[local180]
*p = math.Float32frombits(read32(r))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDText {
- var local183 []uint8
- var local184 uint16
+ var local181 []uint8
+ var local182 uint16
{
- p := &local184
+ p := &local182
*p = read16(r)
}
- (local183) = make([]uint8, local184)
+ (local181) = make([]uint8, local182)
{
- _, err := io.ReadFull(r, (local183)[:])
+ _, err := io.ReadFull(r, (local181)[:])
chk(err)
}
((*(*(struct {
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Text) = string(local183)
+ }))(obj)).Text) = string(local181)
}
if (*(*(struct {
ID HUDID
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDAlign {
- for local185 := range (*(*(struct {
+ for local183 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Align)[local185]
+ }))(obj)).Align)[local183]
*p = math.Float32frombits(read32(r))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDOffset {
- for local186 := range (*(*(struct {
+ for local184 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Offset)[local186]
+ }))(obj)).Offset)[local184]
*p = math.Float32frombits(read32(r))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDSize {
- for local187 := range (*(*(struct {
+ for local185 := range (*(*(struct {
ID HUDID
Field HUDField
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Size)[local187]
+ }))(obj)).Size)[local185]
*p = int32(read32(r))
}
}
//mt:if %s.Field == HUDText2
Text2 string
}))(obj)).Field == HUDText2 {
- var local188 []uint8
- var local189 uint16
+ var local186 []uint8
+ var local187 uint16
{
- p := &local189
+ p := &local187
*p = read16(r)
}
- (local188) = make([]uint8, local189)
+ (local186) = make([]uint8, local187)
{
- _, err := io.ReadFull(r, (local188)[:])
+ _, err := io.ReadFull(r, (local186)[:])
chk(err)
}
((*(*(struct {
//mt:if %s.Field == HUDText2
Text2 string
- }))(obj)).Text2) = string(local188)
+ }))(obj)).Text2) = string(local186)
}
}
Img Texture
}))(obj)).Param == HotbarSize {
{
- local190 := uint16(4) // Size of Size field.
+ local188 := uint16(4) // Size of Size field.
{
- x := local190
+ x := local188
write16(w, uint16(x))
}
}
Img Texture
}))(obj)).Param == HotbarSize {
{
- var local191 uint16
- local192 := uint16(4) // Size of Size field.
+ var local189 uint16
+ local190 := uint16(4) // Size of Size field.
{
- p := &local191
+ p := &local189
*p = read16(r)
}
- if local191 != local192 {
- chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local191))
+ if local189 != local190 {
+ chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local189))
}
}
{
}))(obj)).Textures)))
write16(w, uint16(x))
}
- for local193 := range (*(*(struct {
+ for local191 := range (*(*(struct {
BgColor color.NRGBA
Type string
Clouds bool
DawnSky, DawnHorizon,
NightSky, NightHorizon,
Indoor color.NRGBA
- }))(obj)).Textures)[local193]).serialize(w)
+ }))(obj)).Textures)[local191]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
}
- var local194 []uint8
- var local195 uint16
+ var local192 []uint8
+ var local193 uint16
{
- p := &local195
+ p := &local193
*p = read16(r)
}
- (local194) = make([]uint8, local195)
+ (local192) = make([]uint8, local193)
{
- _, err := io.ReadFull(r, (local194)[:])
+ _, err := io.ReadFull(r, (local192)[:])
chk(err)
}
((*(*(struct {
DawnSky, DawnHorizon,
NightSky, NightHorizon,
Indoor color.NRGBA
- }))(obj)).Type) = string(local194)
+ }))(obj)).Type) = string(local192)
{
p := &(*(*(struct {
BgColor color.NRGBA
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
}
- var local196 []uint8
- var local197 uint16
+ var local194 []uint8
+ var local195 uint16
{
- p := &local197
+ p := &local195
*p = read16(r)
}
- (local196) = make([]uint8, local197)
+ (local194) = make([]uint8, local195)
{
- _, err := io.ReadFull(r, (local196)[:])
+ _, err := io.ReadFull(r, (local194)[:])
chk(err)
}
((*(*(struct {
DawnSky, DawnHorizon,
NightSky, NightHorizon,
Indoor color.NRGBA
- }))(obj)).FogTintType) = string(local196)
+ }))(obj)).FogTintType) = string(local194)
if (*(*(struct {
BgColor color.NRGBA
Type string
NightSky, NightHorizon,
Indoor color.NRGBA
}))(obj)).Type == "skybox" {
- var local198 uint16
+ var local196 uint16
{
- p := &local198
+ p := &local196
*p = read16(r)
}
((*(*(struct {
DawnSky, DawnHorizon,
NightSky, NightHorizon,
Indoor color.NRGBA
- }))(obj)).Textures) = make([]Texture, local198)
- for local199 := range (*(*(struct {
+ }))(obj)).Textures) = make([]Texture, local196)
+ for local197 := range (*(*(struct {
BgColor color.NRGBA
Type string
Clouds bool
DawnSky, DawnHorizon,
NightSky, NightHorizon,
Indoor color.NRGBA
- }))(obj)).Textures)[local199]).deserialize(r)
+ }))(obj)).Textures)[local197]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
- for local200 := range (*(*(struct {
+ for local198 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).Idle {
x := ((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).Idle)[local200]
+ }))(obj)).Idle)[local198]
write32(w, uint32(x))
}
}
- for local201 := range (*(*(struct {
+ for local199 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).Walk {
x := ((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).Walk)[local201]
+ }))(obj)).Walk)[local199]
write32(w, uint32(x))
}
}
- for local202 := range (*(*(struct {
+ for local200 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).Dig {
x := ((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).Dig)[local202]
+ }))(obj)).Dig)[local200]
write32(w, uint32(x))
}
}
- for local203 := range (*(*(struct {
+ for local201 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).WalkDig {
x := ((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).WalkDig)[local203]
+ }))(obj)).WalkDig)[local201]
write32(w, uint32(x))
}
}
}
func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
- for local204 := range (*(*(struct {
+ for local202 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).Idle {
p := &((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).Idle)[local204]
+ }))(obj)).Idle)[local202]
*p = int32(read32(r))
}
}
- for local205 := range (*(*(struct {
+ for local203 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).Walk {
p := &((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).Walk)[local205]
+ }))(obj)).Walk)[local203]
*p = int32(read32(r))
}
}
- for local206 := range (*(*(struct {
+ for local204 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).Dig {
p := &((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).Dig)[local206]
+ }))(obj)).Dig)[local204]
*p = int32(read32(r))
}
}
- for local207 := range (*(*(struct {
+ for local205 := range (*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
}))(obj)).WalkDig {
p := &((*(*(struct {
Idle, Walk, Dig, WalkDig [2]int32
Speed float32
- }))(obj)).WalkDig)[local207]
+ }))(obj)).WalkDig)[local205]
*p = int32(read32(r))
}
}
}))(obj)).Thickness
write32(w, math.Float32bits(x))
}
- for local208 := range (*(*(struct {
+ for local206 := range (*(*(struct {
Density float32
DiffuseColor color.NRGBA
AmbientColor color.NRGBA
Height float32
Thickness float32
Speed [2]float32
- }))(obj)).Speed)[local208]
+ }))(obj)).Speed)[local206]
write32(w, math.Float32bits(x))
}
}
}))(obj)).Thickness
*p = math.Float32frombits(read32(r))
}
- for local209 := range (*(*(struct {
+ for local207 := range (*(*(struct {
Density float32
DiffuseColor color.NRGBA
AmbientColor color.NRGBA
Height float32
Thickness float32
Speed [2]float32
- }))(obj)).Speed)[local209]
+ }))(obj)).Speed)[local207]
*p = math.Float32frombits(read32(r))
}
}
}))(obj)).Players)))
write16(w, uint16(x))
}
- for local210 := range (*(*(struct {
+ for local208 := range (*(*(struct {
Type PlayerListUpdateType
Players []string
}))(obj)).Players {
if len(([]byte(((*(*(struct {
Type PlayerListUpdateType
Players []string
- }))(obj)).Players)[local210]))) > math.MaxUint16 {
+ }))(obj)).Players)[local208]))) > math.MaxUint16 {
chk(ErrTooLong)
}
{
x := uint16(len(([]byte(((*(*(struct {
Type PlayerListUpdateType
Players []string
- }))(obj)).Players)[local210]))))
+ }))(obj)).Players)[local208]))))
write16(w, uint16(x))
}
{
_, err := w.Write(([]byte(((*(*(struct {
Type PlayerListUpdateType
Players []string
- }))(obj)).Players)[local210]))[:])
+ }))(obj)).Players)[local208]))[:])
chk(err)
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.PlayerListUpdateType", err))
}
- var local211 uint16
+ var local209 uint16
{
- p := &local211
+ p := &local209
*p = read16(r)
}
((*(*(struct {
Type PlayerListUpdateType
Players []string
- }))(obj)).Players) = make([]string, local211)
- for local212 := range (*(*(struct {
+ }))(obj)).Players) = make([]string, local209)
+ for local210 := range (*(*(struct {
Type PlayerListUpdateType
Players []string
}))(obj)).Players {
- var local213 []uint8
- var local214 uint16
+ var local211 []uint8
+ var local212 uint16
{
- p := &local214
+ p := &local212
*p = read16(r)
}
- (local213) = make([]uint8, local214)
+ (local211) = make([]uint8, local212)
{
- _, err := io.ReadFull(r, (local213)[:])
+ _, err := io.ReadFull(r, (local211)[:])
chk(err)
}
(((*(*(struct {
Type PlayerListUpdateType
Players []string
- }))(obj)).Players)[local212]) = string(local213)
+ }))(obj)).Players)[local210]) = string(local211)
}
}
}
func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
- var local215 []uint8
- var local216 uint16
+ var local213 []uint8
+ var local214 uint16
{
- p := &local216
+ p := &local214
*p = read16(r)
}
- (local215) = make([]uint8, local216)
+ (local213) = make([]uint8, local214)
{
- _, err := io.ReadFull(r, (local215)[:])
+ _, err := io.ReadFull(r, (local213)[:])
chk(err)
}
((*(*(struct {
Channel string
Sender string
Msg string
- }))(obj)).Channel) = string(local215)
- var local217 []uint8
- var local218 uint16
+ }))(obj)).Channel) = string(local213)
+ var local215 []uint8
+ var local216 uint16
{
- p := &local218
+ p := &local216
*p = read16(r)
}
- (local217) = make([]uint8, local218)
+ (local215) = make([]uint8, local216)
{
- _, err := io.ReadFull(r, (local217)[:])
+ _, err := io.ReadFull(r, (local215)[:])
chk(err)
}
((*(*(struct {
Channel string
Sender string
Msg string
- }))(obj)).Sender) = string(local217)
- var local219 []uint8
- var local220 uint16
+ }))(obj)).Sender) = string(local215)
+ var local217 []uint8
+ var local218 uint16
{
- p := &local220
+ p := &local218
*p = read16(r)
}
- (local219) = make([]uint8, local220)
+ (local217) = make([]uint8, local218)
{
- _, err := io.ReadFull(r, (local219)[:])
+ _, err := io.ReadFull(r, (local217)[:])
chk(err)
}
((*(*(struct {
Channel string
Sender string
Msg string
- }))(obj)).Msg) = string(local219)
+ }))(obj)).Msg) = string(local217)
}
func (obj *ToCltModChanSig) serialize(w io.Writer) {
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ModChanSig", err))
}
- var local221 []uint8
- var local222 uint16
+ var local219 []uint8
+ var local220 uint16
{
- p := &local222
+ p := &local220
*p = read16(r)
}
- (local221) = make([]uint8, local222)
+ (local219) = make([]uint8, local220)
{
- _, err := io.ReadFull(r, (local221)[:])
+ _, err := io.ReadFull(r, (local219)[:])
chk(err)
}
((*(*(struct {
Signal ModChanSig
Channel string
- }))(obj)).Channel) = string(local221)
+ }))(obj)).Channel) = string(local219)
}
func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
}
func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
- var local223 uint16
+ var local221 uint16
{
- p := &local223
+ p := &local221
*p = read16(r)
}
((*(*(struct {
Salt, B []byte
- }))(obj)).Salt) = make([]byte, local223)
+ }))(obj)).Salt) = make([]byte, local221)
{
_, err := io.ReadFull(r, ((*(*(struct {
Salt, B []byte
}))(obj)).Salt)[:])
chk(err)
}
- var local224 uint16
+ var local222 uint16
{
- p := &local224
+ p := &local222
*p = read16(r)
}
((*(*(struct {
Salt, B []byte
- }))(obj)).B) = make([]byte, local224)
+ }))(obj)).B) = make([]byte, local222)
{
_, err := io.ReadFull(r, ((*(*(struct {
Salt, B []byte
}
func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
- var local225 []uint8
- var local226 uint16
+ var local223 []uint8
+ var local224 uint16
{
- p := &local226
+ p := &local224
*p = read16(r)
}
- (local225) = make([]uint8, local226)
+ (local223) = make([]uint8, local224)
{
- _, err := io.ReadFull(r, (local225)[:])
+ _, err := io.ReadFull(r, (local223)[:])
chk(err)
}
((*(*(struct {
Prepend string
- }))(obj)).Prepend) = string(local225)
+ }))(obj)).Prepend) = string(local223)
}
func (obj *AOCmdProps) serialize(w io.Writer) {
}))(obj)).Armor)))
write16(w, uint16(x))
}
- for local227 := range (*(*(struct {
+ for local225 := range (*(*(struct {
Armor []Group
}))(obj)).Armor {
if err := pcall(func() {
(((*(*(struct {
Armor []Group
- }))(obj)).Armor)[local227]).serialize(w)
+ }))(obj)).Armor)[local225]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
- var local228 uint16
+ var local226 uint16
{
- p := &local228
+ p := &local226
*p = read16(r)
}
((*(*(struct {
Armor []Group
- }))(obj)).Armor) = make([]Group, local228)
- for local229 := range (*(*(struct {
+ }))(obj)).Armor) = make([]Group, local226)
+ for local227 := range (*(*(struct {
Armor []Group
}))(obj)).Armor {
if err := pcall(func() {
(((*(*(struct {
Armor []Group
- }))(obj)).Armor)[local229]).deserialize(r)
+ }))(obj)).Armor)[local227]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *AOCmdBonePos) deserialize(r io.Reader) {
- var local230 []uint8
- var local231 uint16
+ var local228 []uint8
+ var local229 uint16
{
- p := &local231
+ p := &local229
*p = read16(r)
}
- (local230) = make([]uint8, local231)
+ (local228) = make([]uint8, local229)
{
- _, err := io.ReadFull(r, (local230)[:])
+ _, err := io.ReadFull(r, (local228)[:])
chk(err)
}
((*(*(struct {
Bone string
Pos AOBonePos
- }))(obj)).Bone) = string(local230)
+ }))(obj)).Bone) = string(local228)
if err := pcall(func() {
((*(*(struct {
Bone string
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
}
{
- local232 := genericCAO
+ local230 := genericCAO
if err := pcall(func() {
- (local232).serialize(w)
+ (local230).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
}
{
- var local233 aoType
- local234 := genericCAO
+ var local231 aoType
+ local232 := genericCAO
if err := pcall(func() {
- (local233).deserialize(r)
+ (local231).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
}
- if local233 != local234 {
- chk(fmt.Errorf("const %v: %v", "genericCAO", local233))
+ if local231 != local232 {
+ chk(fmt.Errorf("const %v: %v", "genericCAO", local231))
}
}
}
}))(obj)).Fields)))
write32(w, uint32(x))
}
- for local235 := range (*(*(struct {
+ for local233 := range (*(*(struct {
//mt:len32
Fields []NodeMetaField
Fields []NodeMetaField
Inv Inv
- }))(obj)).Fields)[local235]).serialize(w)
+ }))(obj)).Fields)[local233]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *NodeMeta) deserialize(r io.Reader) {
- var local236 uint32
+ var local234 uint32
{
- p := &local236
+ p := &local234
*p = read32(r)
}
((*(*(struct {
Fields []NodeMetaField
Inv Inv
- }))(obj)).Fields) = make([]NodeMetaField, local236)
- for local237 := range (*(*(struct {
+ }))(obj)).Fields) = make([]NodeMetaField, local234)
+ for local235 := range (*(*(struct {
//mt:len32
Fields []NodeMetaField
Fields []NodeMetaField
Inv Inv
- }))(obj)).Fields)[local237]).deserialize(r)
+ }))(obj)).Fields)[local235]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.MinimapType", err))
}
- var local238 []uint8
- var local239 uint16
+ var local236 []uint8
+ var local237 uint16
{
- p := &local239
+ p := &local237
*p = read16(r)
}
- (local238) = make([]uint8, local239)
+ (local236) = make([]uint8, local237)
{
- _, err := io.ReadFull(r, (local238)[:])
+ _, err := io.ReadFull(r, (local236)[:])
chk(err)
}
((*(*(struct {
Size uint16
Texture
Scale uint16
- }))(obj)).Label) = string(local238)
+ }))(obj)).Label) = string(local236)
{
p := &(*(*(struct {
Type MinimapType
ow := w
w := new(bytes.Buffer)
{
- local240 := uint8(13)
+ local238 := uint8(13)
{
- x := local240
+ x := local238
write8(w, uint8(x))
}
}
}))(obj)).Groups)))
write16(w, uint16(x))
}
- for local241 := range (*(*(struct {
+ for local239 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).Groups)[local241]).serialize(w)
+ }))(obj)).Groups)[local239]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
write32(w, math.Float32bits(x))
}
{
- local242 := uint8(6)
+ local240 := uint8(6)
{
- x := local242
+ x := local240
write8(w, uint8(x))
}
}
- for local243 := range (*(*(struct {
+ for local241 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).Tiles)[local243]).serialize(w)
+ }))(obj)).Tiles)[local241]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
}
}
- for local244 := range (*(*(struct {
+ for local242 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).OverlayTiles)[local244]).serialize(w)
+ }))(obj)).OverlayTiles)[local242]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
}
{
- local245 := uint8(6)
+ local243 := uint8(6)
{
- x := local245
+ x := local243
write8(w, uint8(x))
}
}
- for local246 := range (*(*(struct {
+ for local244 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).SpecialTiles)[local246]).serialize(w)
+ }))(obj)).SpecialTiles)[local244]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).ConnectTo)))
write16(w, uint16(x))
}
- for local247 := range (*(*(struct {
+ for local245 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).ConnectTo)[local247]).serialize(w)
+ }))(obj)).ConnectTo)[local245]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
r := &io.LimitedReader{R: r, N: int64(n)}
{
- var local248 uint8
- local249 := uint8(13)
+ var local246 uint8
+ local247 := uint8(13)
{
- p := &local248
+ p := &local246
*p = read8(r)
}
- if local248 != local249 {
- chk(fmt.Errorf("const %v: %v", "uint8(13)", local248))
+ if local246 != local247 {
+ chk(fmt.Errorf("const %v: %v", "uint8(13)", local246))
}
}
- var local250 []uint8
- var local251 uint16
+ var local248 []uint8
+ var local249 uint16
{
- p := &local251
+ p := &local249
*p = read16(r)
}
- (local250) = make([]uint8, local251)
+ (local248) = make([]uint8, local249)
{
- _, err := io.ReadFull(r, (local250)[:])
+ _, err := io.ReadFull(r, (local248)[:])
chk(err)
}
((*(*(struct {
MaxLvl uint8
AlphaUse
- }))(obj)).Name) = string(local250)
- var local252 uint16
+ }))(obj)).Name) = string(local248)
+ var local250 uint16
{
- p := &local252
+ p := &local250
*p = read16(r)
}
((*(*(struct {
MaxLvl uint8
AlphaUse
- }))(obj)).Groups) = make([]Group, local252)
- for local253 := range (*(*(struct {
+ }))(obj)).Groups) = make([]Group, local250)
+ for local251 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).Groups)[local253]).deserialize(r)
+ }))(obj)).Groups)[local251]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DrawType", err))
}
- var local254 []uint8
- var local255 uint16
+ var local252 []uint8
+ var local253 uint16
{
- p := &local255
+ p := &local253
*p = read16(r)
}
- (local254) = make([]uint8, local255)
+ (local252) = make([]uint8, local253)
{
- _, err := io.ReadFull(r, (local254)[:])
+ _, err := io.ReadFull(r, (local252)[:])
chk(err)
}
((*(*(struct {
MaxLvl uint8
AlphaUse
- }))(obj)).Mesh) = string(local254)
+ }))(obj)).Mesh) = string(local252)
{
p := &(*(*(struct {
Param0 Content
*p = math.Float32frombits(read32(r))
}
{
- var local256 uint8
- local257 := uint8(6)
+ var local254 uint8
+ local255 := uint8(6)
{
- p := &local256
+ p := &local254
*p = read8(r)
}
- if local256 != local257 {
- chk(fmt.Errorf("const %v: %v", "uint8(6)", local256))
+ if local254 != local255 {
+ chk(fmt.Errorf("const %v: %v", "uint8(6)", local254))
}
}
- for local258 := range (*(*(struct {
+ for local256 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).Tiles)[local258]).deserialize(r)
+ }))(obj)).Tiles)[local256]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.TileDef", err))
}
}
- for local259 := range (*(*(struct {
+ for local257 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).OverlayTiles)[local259]).deserialize(r)
+ }))(obj)).OverlayTiles)[local257]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
}
{
- var local260 uint8
- local261 := uint8(6)
+ var local258 uint8
+ local259 := uint8(6)
{
- p := &local260
+ p := &local258
*p = read8(r)
}
- if local260 != local261 {
- chk(fmt.Errorf("const %v: %v", "uint8(6)", local260))
+ if local258 != local259 {
+ chk(fmt.Errorf("const %v: %v", "uint8(6)", local258))
}
}
- for local262 := range (*(*(struct {
+ for local260 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).SpecialTiles)[local262]).deserialize(r)
+ }))(obj)).SpecialTiles)[local260]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).ConnectSides
*p = read8(r)
}
- var local263 uint16
+ var local261 uint16
{
- p := &local263
+ p := &local261
*p = read16(r)
}
((*(*(struct {
MaxLvl uint8
AlphaUse
- }))(obj)).ConnectTo) = make([]Content, local263)
- for local264 := range (*(*(struct {
+ }))(obj)).ConnectTo) = make([]Content, local261)
+ for local262 := range (*(*(struct {
Param0 Content
Name string
MaxLvl uint8
AlphaUse
- }))(obj)).ConnectTo)[local264]).deserialize(r)
+ }))(obj)).ConnectTo)[local262]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LiquidType", err))
}
- var local265 []uint8
- var local266 uint16
+ var local263 []uint8
+ var local264 uint16
{
- p := &local266
+ p := &local264
*p = read16(r)
}
- (local265) = make([]uint8, local266)
+ (local263) = make([]uint8, local264)
{
- _, err := io.ReadFull(r, (local265)[:])
+ _, err := io.ReadFull(r, (local263)[:])
chk(err)
}
((*(*(struct {
MaxLvl uint8
AlphaUse
- }))(obj)).FlowingAlt) = string(local265)
- var local267 []uint8
- var local268 uint16
+ }))(obj)).FlowingAlt) = string(local263)
+ var local265 []uint8
+ var local266 uint16
{
- p := &local268
+ p := &local266
*p = read16(r)
}
- (local267) = make([]uint8, local268)
+ (local265) = make([]uint8, local266)
{
- _, err := io.ReadFull(r, (local267)[:])
+ _, err := io.ReadFull(r, (local265)[:])
chk(err)
}
((*(*(struct {
MaxLvl uint8
AlphaUse
- }))(obj)).SrcAlt) = string(local267)
+ }))(obj)).SrcAlt) = string(local265)
{
p := &(*(*(struct {
Param0 Content
}
}
- var local269 []uint8
- var local270 uint16
+ var local267 []uint8
+ var local268 uint16
{
- p := &local270
+ p := &local268
*p = read16(r)
}
- (local269) = make([]uint8, local270)
+ (local267) = make([]uint8, local268)
{
- _, err := io.ReadFull(r, (local269)[:])
+ _, err := io.ReadFull(r, (local267)[:])
chk(err)
}
((*(*(struct {
MaxLvl uint8
AlphaUse
- }))(obj)).DigPredict) = string(local269)
+ }))(obj)).DigPredict) = string(local267)
{
p := &(*(*(struct {
Param0 Content
}
func (obj *PointedNode) serialize(w io.Writer) {
- for local271 := range (*(*(struct {
+ for local269 := range (*(*(struct {
Under, Above [3]int16
}))(obj)).Under {
{
x := ((*(*(struct {
Under, Above [3]int16
- }))(obj)).Under)[local271]
+ }))(obj)).Under)[local269]
write16(w, uint16(x))
}
}
- for local272 := range (*(*(struct {
+ for local270 := range (*(*(struct {
Under, Above [3]int16
}))(obj)).Above {
{
x := ((*(*(struct {
Under, Above [3]int16
- }))(obj)).Above)[local272]
+ }))(obj)).Above)[local270]
write16(w, uint16(x))
}
}
}
func (obj *PointedNode) deserialize(r io.Reader) {
- for local273 := range (*(*(struct {
+ for local271 := range (*(*(struct {
Under, Above [3]int16
}))(obj)).Under {
{
p := &((*(*(struct {
Under, Above [3]int16
- }))(obj)).Under)[local273]
+ }))(obj)).Under)[local271]
*p = int16(read16(r))
}
}
- for local274 := range (*(*(struct {
+ for local272 := range (*(*(struct {
Under, Above [3]int16
}))(obj)).Above {
{
p := &((*(*(struct {
Under, Above [3]int16
- }))(obj)).Above)[local274]
+ }))(obj)).Above)[local272]
*p = int16(read16(r))
}
}
}
func (obj *PlayerPos) serialize(w io.Writer) {
- for local275 := range (*(*(struct {
+ for local273 := range (*(*(struct {
Pos100, Vel100 [3]int32
Pitch100, Yaw100 int32
Keys Keys
Keys Keys
FOV80 uint8
WantedRange uint8 // in MapBlks.
- }))(obj)).Pos100)[local275]
+ }))(obj)).Pos100)[local273]
write32(w, uint32(x))
}
}
- for local276 := range (*(*(struct {
+ for local274 := range (*(*(struct {
Pos100, Vel100 [3]int32
Pitch100, Yaw100 int32
Keys Keys
Keys Keys
FOV80 uint8
WantedRange uint8 // in MapBlks.
- }))(obj)).Vel100)[local276]
+ }))(obj)).Vel100)[local274]
write32(w, uint32(x))
}
}
}
func (obj *PlayerPos) deserialize(r io.Reader) {
- for local277 := range (*(*(struct {
+ for local275 := range (*(*(struct {
Pos100, Vel100 [3]int32
Pitch100, Yaw100 int32
Keys Keys
Keys Keys
FOV80 uint8
WantedRange uint8 // in MapBlks.
- }))(obj)).Pos100)[local277]
+ }))(obj)).Pos100)[local275]
*p = int32(read32(r))
}
}
- for local278 := range (*(*(struct {
+ for local276 := range (*(*(struct {
Pos100, Vel100 [3]int32
Pitch100, Yaw100 int32
Keys Keys
Keys Keys
FOV80 uint8
WantedRange uint8 // in MapBlks.
- }))(obj)).Vel100)[local278]
+ }))(obj)).Vel100)[local276]
*p = int32(read32(r))
}
}
}
func (obj *Field) deserialize(r io.Reader) {
- var local279 []uint8
- var local280 uint16
+ var local277 []uint8
+ var local278 uint16
{
- p := &local280
+ p := &local278
*p = read16(r)
}
- (local279) = make([]uint8, local280)
+ (local277) = make([]uint8, local278)
{
- _, err := io.ReadFull(r, (local279)[:])
+ _, err := io.ReadFull(r, (local277)[:])
chk(err)
}
((*(*(struct {
//mt:len32
Value string
- }))(obj)).Name) = string(local279)
- var local281 []uint8
- var local282 uint32
+ }))(obj)).Name) = string(local277)
+ var local279 []uint8
+ var local280 uint32
{
- p := &local282
+ p := &local280
*p = read32(r)
}
- (local281) = make([]uint8, local282)
+ (local279) = make([]uint8, local280)
{
- _, err := io.ReadFull(r, (local281)[:])
+ _, err := io.ReadFull(r, (local279)[:])
chk(err)
}
((*(*(struct {
//mt:len32
Value string
- }))(obj)).Value) = string(local281)
+ }))(obj)).Value) = string(local279)
}
func (obj *AuthMethods) serialize(w io.Writer) {
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
}
{
- local283 := uint8(2) // Size of param0 in bytes.
+ local281 := uint8(2) // Size of param0 in bytes.
{
- x := local283
+ x := local281
write8(w, uint8(x))
}
}
{
- local284 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
+ local282 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
{
- x := local284
+ x := local282
write8(w, uint8(x))
}
}
{
w, err := zstd.NewWriter(w)
chk(err)
- for local285 := range (*(*(struct {
+ for local283 := range (*(*(struct {
Flags MapBlkFlags
LitFrom LitFromBlks
Param2 [4096]uint8
NodeMetas map[uint16]*NodeMeta
- }))(obj)).Param0)[local285]).serialize(w)
+ }))(obj)).Param0)[local283]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
{
- local286 := uint8(2) // version
+ local284 := uint8(2) // version
{
- x := local286
+ x := local284
write8(w, uint8(x))
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.LitFromBlks", err))
}
{
- var local287 uint8
- local288 := uint8(2) // Size of param0 in bytes.
+ var local285 uint8
+ local286 := uint8(2) // Size of param0 in bytes.
{
- p := &local287
+ p := &local285
*p = read8(r)
}
- if local287 != local288 {
- chk(fmt.Errorf("const %v: %v", "uint8(2) // Size of param0 in bytes.", local287))
+ if local285 != local286 {
+ chk(fmt.Errorf("const %v: %v", "uint8(2) // Size of param0 in bytes.", local285))
}
}
{
- var local289 uint8
- local290 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
+ var local287 uint8
+ local288 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
{
- p := &local289
+ p := &local287
*p = read8(r)
}
- if local289 != local290 {
- chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local289))
+ if local287 != local288 {
+ chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local287))
}
}
{
r, err := zstd.NewReader(byteReader{r})
chk(err)
- for local291 := range (*(*(struct {
+ for local289 := range (*(*(struct {
Flags MapBlkFlags
LitFrom LitFromBlks
Param2 [4096]uint8
NodeMetas map[uint16]*NodeMeta
- }))(obj)).Param0)[local291]).deserialize(r)
+ }))(obj)).Param0)[local289]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
{
- var local292 uint8
- local293 := uint8(2) // version
+ var local290 uint8
+ local291 := uint8(2) // version
{
- p := &local292
+ p := &local290
*p = read8(r)
}
- if local292 != local293 {
- chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local292))
+ if local290 != local291 {
+ chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local290))
}
}
}
}
func (obj *Vec) serialize(w io.Writer) {
- for local294 := range *(*([3]float32))(obj) {
+ for local292 := range *(*([3]float32))(obj) {
{
- x := (*(*([3]float32))(obj))[local294]
+ x := (*(*([3]float32))(obj))[local292]
write32(w, math.Float32bits(x))
}
}
}
func (obj *Vec) deserialize(r io.Reader) {
- for local295 := range *(*([3]float32))(obj) {
+ for local293 := range *(*([3]float32))(obj) {
{
- p := &(*(*([3]float32))(obj))[local295]
+ p := &(*(*([3]float32))(obj))[local293]
*p = math.Float32frombits(read32(r))
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
}
{
- local296 := genericCAO
+ local294 := genericCAO
if err := pcall(func() {
- (local296).serialize(w)
+ (local294).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
}
{
- var local297 aoType
- local298 := genericCAO
+ var local295 aoType
+ local296 := genericCAO
if err := pcall(func() {
- (local297).deserialize(r)
+ (local295).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.aoType", err))
}
- if local297 != local298 {
- chk(fmt.Errorf("const %v: %v", "genericCAO", local297))
+ if local295 != local296 {
+ chk(fmt.Errorf("const %v: %v", "genericCAO", local295))
}
}
{
ow := w
w := new(bytes.Buffer)
{
- local299 := uint8(6)
+ local297 := uint8(6)
{
- x := local299
+ x := local297
write8(w, uint8(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
}
- for local300 := range (*(*(struct {
+ for local298 := range (*(*(struct {
Type ItemType
Name, Desc string
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).WieldScale)[local300]
+ }))(obj)).WieldScale)[local298]
write32(w, math.Float32bits(x))
}
}
}))(obj)).Groups)))
write16(w, uint16(x))
}
- for local301 := range (*(*(struct {
+ for local299 := range (*(*(struct {
Type ItemType
Name, Desc string
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).Groups)[local301]).serialize(w)
+ }))(obj)).Groups)[local299]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
r := &io.LimitedReader{R: r, N: int64(n)}
{
- var local302 uint8
- local303 := uint8(6)
+ var local300 uint8
+ local301 := uint8(6)
{
- p := &local302
+ p := &local300
*p = read8(r)
}
- if local302 != local303 {
- chk(fmt.Errorf("const %v: %v", "uint8(6)", local302))
+ if local300 != local301 {
+ chk(fmt.Errorf("const %v: %v", "uint8(6)", local300))
}
}
if err := pcall(func() {
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ItemType", err))
}
- var local304 []uint8
- var local305 uint16
+ var local302 []uint8
+ var local303 uint16
{
- p := &local305
+ p := &local303
*p = read16(r)
}
- (local304) = make([]uint8, local305)
+ (local302) = make([]uint8, local303)
{
- _, err := io.ReadFull(r, (local304)[:])
+ _, err := io.ReadFull(r, (local302)[:])
chk(err)
}
((*(*(struct {
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).Name) = string(local304)
- var local306 []uint8
- var local307 uint16
+ }))(obj)).Name) = string(local302)
+ var local304 []uint8
+ var local305 uint16
{
- p := &local307
+ p := &local305
*p = read16(r)
}
- (local306) = make([]uint8, local307)
+ (local304) = make([]uint8, local305)
{
- _, err := io.ReadFull(r, (local306)[:])
+ _, err := io.ReadFull(r, (local304)[:])
chk(err)
}
((*(*(struct {
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).Desc) = string(local306)
+ }))(obj)).Desc) = string(local304)
if err := pcall(func() {
((*(*(struct {
Type ItemType
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
}
- for local308 := range (*(*(struct {
+ for local306 := range (*(*(struct {
Type ItemType
Name, Desc string
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).WieldScale)[local308]
+ }))(obj)).WieldScale)[local306]
*p = math.Float32frombits(read32(r))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolCaps", err))
}
- var local309 uint16
+ var local307 uint16
{
- p := &local309
+ p := &local307
*p = read16(r)
}
((*(*(struct {
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).Groups) = make([]Group, local309)
- for local310 := range (*(*(struct {
+ }))(obj)).Groups) = make([]Group, local307)
+ for local308 := range (*(*(struct {
Type ItemType
Name, Desc string
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).Groups)[local310]).deserialize(r)
+ }))(obj)).Groups)[local308]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
}
}
- var local311 []uint8
- var local312 uint16
+ var local309 []uint8
+ var local310 uint16
{
- p := &local312
+ p := &local310
*p = read16(r)
}
- (local311) = make([]uint8, local312)
+ (local309) = make([]uint8, local310)
{
- _, err := io.ReadFull(r, (local311)[:])
+ _, err := io.ReadFull(r, (local309)[:])
chk(err)
}
((*(*(struct {
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).PlacePredict) = string(local311)
+ }))(obj)).PlacePredict) = string(local309)
if err := pcall(func() {
((*(*(struct {
Type ItemType
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
}
- var local313 []uint8
- var local314 uint16
+ var local311 []uint8
+ var local312 uint16
{
- p := &local314
+ p := &local312
*p = read16(r)
}
- (local313) = make([]uint8, local314)
+ (local311) = make([]uint8, local312)
{
- _, err := io.ReadFull(r, (local313)[:])
+ _, err := io.ReadFull(r, (local311)[:])
chk(err)
}
((*(*(struct {
InvOverlay, WieldOverlay Texture
ShortDesc string
- }))(obj)).ShortDesc) = string(local313)
+ }))(obj)).ShortDesc) = string(local311)
if r.N > 0 {
chk(fmt.Errorf("%d bytes of trailing data", r.N))
}
Duration float32 // in seconds
}))(obj)).Type == VerticalFrameAnim {
- for local315 := range (*(*(struct {
+ for local313 := range (*(*(struct {
Type AnimType
//mt:if %s.Type == SpriteSheetAnim
//mt:if %s.Type != NoAnim
Duration float32 // in seconds
- }))(obj)).NFrames)[local315]
+ }))(obj)).NFrames)[local313]
write16(w, uint16(x))
}
}
Duration float32 // in seconds
}))(obj)).Type == VerticalFrameAnim {
- for local316 := range (*(*(struct {
+ for local314 := range (*(*(struct {
Type AnimType
//mt:if %s.Type == SpriteSheetAnim
//mt:if %s.Type != NoAnim
Duration float32 // in seconds
- }))(obj)).NFrames)[local316]
+ }))(obj)).NFrames)[local314]
*p = read16(r)
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
}
- for local317 := range (*(*(struct {
+ for local315 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Pos)[local317]
+ }))(obj)).Pos)[local315]
write32(w, math.Float32bits(x))
}
}
}))(obj)).Name))[:])
chk(err)
}
- for local318 := range (*(*(struct {
+ for local316 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Scale)[local318]
+ }))(obj)).Scale)[local316]
write32(w, math.Float32bits(x))
}
}
}))(obj)).Dir
write32(w, uint32(x))
}
- for local319 := range (*(*(struct {
+ for local317 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Align)[local319]
+ }))(obj)).Align)[local317]
write32(w, math.Float32bits(x))
}
}
- for local320 := range (*(*(struct {
+ for local318 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Offset)[local320]
+ }))(obj)).Offset)[local318]
write32(w, math.Float32bits(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
}
- for local321 := range (*(*(struct {
+ for local319 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Size)[local321]
+ }))(obj)).Size)[local319]
write32(w, uint32(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.HUDType", err))
}
- for local322 := range (*(*(struct {
+ for local320 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Pos)[local322]
+ }))(obj)).Pos)[local320]
*p = math.Float32frombits(read32(r))
}
}
- var local323 []uint8
- var local324 uint16
+ var local321 []uint8
+ var local322 uint16
{
- p := &local324
+ p := &local322
*p = read16(r)
}
- (local323) = make([]uint8, local324)
+ (local321) = make([]uint8, local322)
{
- _, err := io.ReadFull(r, (local323)[:])
+ _, err := io.ReadFull(r, (local321)[:])
chk(err)
}
((*(*(struct {
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Name) = string(local323)
- for local325 := range (*(*(struct {
+ }))(obj)).Name) = string(local321)
+ for local323 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Scale)[local325]
+ }))(obj)).Scale)[local323]
*p = math.Float32frombits(read32(r))
}
}
- var local326 []uint8
- var local327 uint16
+ var local324 []uint8
+ var local325 uint16
{
- p := &local327
+ p := &local325
*p = read16(r)
}
- (local326) = make([]uint8, local327)
+ (local324) = make([]uint8, local325)
{
- _, err := io.ReadFull(r, (local326)[:])
+ _, err := io.ReadFull(r, (local324)[:])
chk(err)
}
((*(*(struct {
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Text) = string(local326)
+ }))(obj)).Text) = string(local324)
{
p := &(*(*(struct {
Type HUDType
}))(obj)).Dir
*p = read32(r)
}
- for local328 := range (*(*(struct {
+ for local326 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Align)[local328]
+ }))(obj)).Align)[local326]
*p = math.Float32frombits(read32(r))
}
}
- for local329 := range (*(*(struct {
+ for local327 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Offset)[local329]
+ }))(obj)).Offset)[local327]
*p = math.Float32frombits(read32(r))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
}
- for local330 := range (*(*(struct {
+ for local328 := range (*(*(struct {
Type HUDType
Pos [2]float32
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Size)[local330]
+ }))(obj)).Size)[local328]
*p = int32(read32(r))
}
}
}))(obj)).ZIndex
*p = int16(read16(r))
}
- var local331 []uint8
- var local332 uint16
+ var local329 []uint8
+ var local330 uint16
{
- p := &local332
+ p := &local330
*p = read16(r)
}
- (local331) = make([]uint8, local332)
+ (local329) = make([]uint8, local330)
{
- _, err := io.ReadFull(r, (local331)[:])
+ _, err := io.ReadFull(r, (local329)[:])
chk(err)
}
((*(*(struct {
Size [2]int32
ZIndex int16
Text2 string
- }))(obj)).Text2) = string(local331)
+ }))(obj)).Text2) = string(local329)
}
func (obj *HUDField) serialize(w io.Writer) {
}
func (obj *Texture) deserialize(r io.Reader) {
- var local333 []uint8
- var local334 uint16
+ var local331 []uint8
+ var local332 uint16
{
- p := &local334
+ p := &local332
*p = read16(r)
}
- (local333) = make([]uint8, local334)
+ (local331) = make([]uint8, local332)
{
- _, err := io.ReadFull(r, (local333)[:])
+ _, err := io.ReadFull(r, (local331)[:])
chk(err)
}
- (*(*(string))(obj)) = string(local333)
+ (*(*(string))(obj)) = string(local331)
}
func (obj *PlayerListUpdateType) serialize(w io.Writer) {
func (obj *AOProps) serialize(w io.Writer) {
{
- local335 := uint8(4)
+ local333 := uint8(4)
{
- x := local335
+ x := local333
write8(w, uint8(x))
}
}
}))(obj)).Visual))[:])
chk(err)
}
- for local336 := range (*(*(struct {
+ for local334 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).VisualSize)[local336]
+ }))(obj)).VisualSize)[local334]
write32(w, math.Float32bits(x))
}
}
}))(obj)).Textures)))
write16(w, uint16(x))
}
- for local337 := range (*(*(struct {
+ for local335 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Textures)[local337]).serialize(w)
+ }))(obj)).Textures)[local335]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
}
}
- for local338 := range (*(*(struct {
+ for local336 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).SpriteSheetSize)[local338]
+ }))(obj)).SpriteSheetSize)[local336]
write16(w, uint16(x))
}
}
- for local339 := range (*(*(struct {
+ for local337 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).SpritePos)[local339]
+ }))(obj)).SpritePos)[local337]
write16(w, uint16(x))
}
}
}))(obj)).Colors)))
write16(w, uint16(x))
}
- for local340 := range (*(*(struct {
+ for local338 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Colors)[local340]
+ }))(obj)).Colors)[local338]
w.Write([]byte{x.A, x.R, x.G, x.B})
}
func (obj *AOProps) deserialize(r io.Reader) {
{
- var local341 uint8
- local342 := uint8(4)
+ var local339 uint8
+ local340 := uint8(4)
{
- p := &local341
+ p := &local339
*p = read8(r)
}
- if local341 != local342 {
- chk(fmt.Errorf("const %v: %v", "uint8(4)", local341))
+ if local339 != local340 {
+ chk(fmt.Errorf("const %v: %v", "uint8(4)", local339))
}
}
{
}
}
- var local343 []uint8
- var local344 uint16
+ var local341 []uint8
+ var local342 uint16
{
- p := &local344
+ p := &local342
*p = read16(r)
}
- (local343) = make([]uint8, local344)
+ (local341) = make([]uint8, local342)
{
- _, err := io.ReadFull(r, (local343)[:])
+ _, err := io.ReadFull(r, (local341)[:])
chk(err)
}
((*(*(struct {
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Visual) = string(local343)
- for local345 := range (*(*(struct {
+ }))(obj)).Visual) = string(local341)
+ for local343 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).VisualSize)[local345]
+ }))(obj)).VisualSize)[local343]
*p = math.Float32frombits(read32(r))
}
}
- var local346 uint16
+ var local344 uint16
{
- p := &local346
+ p := &local344
*p = read16(r)
}
((*(*(struct {
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Textures) = make([]Texture, local346)
- for local347 := range (*(*(struct {
+ }))(obj)).Textures) = make([]Texture, local344)
+ for local345 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Textures)[local347]).deserialize(r)
+ }))(obj)).Textures)[local345]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Texture", err))
}
}
- for local348 := range (*(*(struct {
+ for local346 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).SpriteSheetSize)[local348]
+ }))(obj)).SpriteSheetSize)[local346]
*p = int16(read16(r))
}
}
- for local349 := range (*(*(struct {
+ for local347 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).SpritePos)[local349]
+ }))(obj)).SpritePos)[local347]
*p = int16(read16(r))
}
}
}))(obj)).RotateSpeed
*p = math.Float32frombits(read32(r))
}
- var local350 []uint8
- var local351 uint16
+ var local348 []uint8
+ var local349 uint16
{
- p := &local351
+ p := &local349
*p = read16(r)
}
- (local350) = make([]uint8, local351)
+ (local348) = make([]uint8, local349)
{
- _, err := io.ReadFull(r, (local350)[:])
+ _, err := io.ReadFull(r, (local348)[:])
chk(err)
}
((*(*(struct {
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Mesh) = string(local350)
- var local352 uint16
+ }))(obj)).Mesh) = string(local348)
+ var local350 uint16
{
- p := &local352
+ p := &local350
*p = read16(r)
}
((*(*(struct {
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Colors) = make([]color.NRGBA, local352)
- for local353 := range (*(*(struct {
+ }))(obj)).Colors) = make([]color.NRGBA, local350)
+ for local351 := range (*(*(struct {
MaxHP uint16 // Player only.
CollideWithNodes bool
Weight float32 // deprecated
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Colors)[local353]
+ }))(obj)).Colors)[local351]
*p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
}
}
}
- var local354 []uint8
- var local355 uint16
+ var local352 []uint8
+ var local353 uint16
{
- p := &local355
+ p := &local353
*p = read16(r)
}
- (local354) = make([]uint8, local355)
+ (local352) = make([]uint8, local353)
{
- _, err := io.ReadFull(r, (local354)[:])
+ _, err := io.ReadFull(r, (local352)[:])
chk(err)
}
((*(*(struct {
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Nametag) = string(local354)
+ }))(obj)).Nametag) = string(local352)
{
p := &(*(*(struct {
MaxHP uint16 // Player only.
}))(obj)).FaceRotateSpeed
*p = math.Float32frombits(read32(r))
}
- var local356 []uint8
- var local357 uint16
+ var local354 []uint8
+ var local355 uint16
{
- p := &local357
+ p := &local355
*p = read16(r)
}
- (local356) = make([]uint8, local357)
+ (local354) = make([]uint8, local355)
{
- _, err := io.ReadFull(r, (local356)[:])
+ _, err := io.ReadFull(r, (local354)[:])
chk(err)
}
((*(*(struct {
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Infotext) = string(local356)
- var local358 []uint8
- var local359 uint16
+ }))(obj)).Infotext) = string(local354)
+ var local356 []uint8
+ var local357 uint16
{
- p := &local359
+ p := &local357
*p = read16(r)
}
- (local358) = make([]uint8, local359)
+ (local356) = make([]uint8, local357)
{
- _, err := io.ReadFull(r, (local358)[:])
+ _, err := io.ReadFull(r, (local356)[:])
chk(err)
}
((*(*(struct {
Shaded bool
ShowOnMinimap bool
NametagBG color.NRGBA
- }))(obj)).Itemstring) = string(local358)
+ }))(obj)).Itemstring) = string(local356)
{
p := &(*(*(struct {
MaxHP uint16 // Player only.
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
}
- for local360 := range (*(*(struct {
+ for local358 := range (*(*(struct {
Pos
Vel, Acc Vec
Rot [3]float32
Interpolate bool
End bool
UpdateInterval float32
- }))(obj)).Rot)[local360]
+ }))(obj)).Rot)[local358]
write32(w, math.Float32bits(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
}
- for local361 := range (*(*(struct {
+ for local359 := range (*(*(struct {
Pos
Vel, Acc Vec
Rot [3]float32
Interpolate bool
End bool
UpdateInterval float32
- }))(obj)).Rot)[local361]
+ }))(obj)).Rot)[local359]
*p = math.Float32frombits(read32(r))
}
}
}
func (obj *AOSprite) serialize(w io.Writer) {
- for local362 := range (*(*(struct {
+ for local360 := range (*(*(struct {
Frame0 [2]int16
Frames uint16
FrameDuration float32
Frames uint16
FrameDuration float32
ViewAngleFrames bool
- }))(obj)).Frame0)[local362]
+ }))(obj)).Frame0)[local360]
write16(w, uint16(x))
}
}
}
func (obj *AOSprite) deserialize(r io.Reader) {
- for local363 := range (*(*(struct {
+ for local361 := range (*(*(struct {
Frame0 [2]int16
Frames uint16
FrameDuration float32
Frames uint16
FrameDuration float32
ViewAngleFrames bool
- }))(obj)).Frame0)[local363]
+ }))(obj)).Frame0)[local361]
*p = int16(read16(r))
}
}
}
func (obj *Group) deserialize(r io.Reader) {
- var local364 []uint8
- var local365 uint16
+ var local362 []uint8
+ var local363 uint16
{
- p := &local365
+ p := &local363
*p = read16(r)
}
- (local364) = make([]uint8, local365)
+ (local362) = make([]uint8, local363)
{
- _, err := io.ReadFull(r, (local364)[:])
+ _, err := io.ReadFull(r, (local362)[:])
chk(err)
}
((*(*(struct {
Name string
Rating int16
- }))(obj)).Name) = string(local364)
+ }))(obj)).Name) = string(local362)
{
p := &(*(*(struct {
Name string
}
func (obj *AOAnim) serialize(w io.Writer) {
- for local366 := range (*(*(struct {
+ for local364 := range (*(*(struct {
Frames [2]int32
Speed float32
Blend float32
Speed float32
Blend float32
NoLoop bool
- }))(obj)).Frames)[local366]
+ }))(obj)).Frames)[local364]
write32(w, uint32(x))
}
}
}
func (obj *AOAnim) deserialize(r io.Reader) {
- for local367 := range (*(*(struct {
+ for local365 := range (*(*(struct {
Frames [2]int32
Speed float32
Blend float32
Speed float32
Blend float32
NoLoop bool
- }))(obj)).Frames)[local367]
+ }))(obj)).Frames)[local365]
*p = int32(read32(r))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
}
- for local368 := range (*(*(struct {
+ for local366 := range (*(*(struct {
Pos Vec
Rot [3]float32
}))(obj)).Rot {
x := ((*(*(struct {
Pos Vec
Rot [3]float32
- }))(obj)).Rot)[local368]
+ }))(obj)).Rot)[local366]
write32(w, math.Float32bits(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
}
- for local369 := range (*(*(struct {
+ for local367 := range (*(*(struct {
Pos Vec
Rot [3]float32
}))(obj)).Rot {
p := &((*(*(struct {
Pos Vec
Rot [3]float32
- }))(obj)).Rot)[local369]
+ }))(obj)).Rot)[local367]
*p = math.Float32frombits(read32(r))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
}
- for local370 := range (*(*(struct {
+ for local368 := range (*(*(struct {
ParentID AOID
Bone string
Pos Vec
Pos Vec
Rot [3]float32
ForceVisible bool
- }))(obj)).Rot)[local370]
+ }))(obj)).Rot)[local368]
write32(w, math.Float32bits(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.AOID", err))
}
- var local371 []uint8
- var local372 uint16
+ var local369 []uint8
+ var local370 uint16
{
- p := &local372
+ p := &local370
*p = read16(r)
}
- (local371) = make([]uint8, local372)
+ (local369) = make([]uint8, local370)
{
- _, err := io.ReadFull(r, (local371)[:])
+ _, err := io.ReadFull(r, (local369)[:])
chk(err)
}
((*(*(struct {
Pos Vec
Rot [3]float32
ForceVisible bool
- }))(obj)).Bone) = string(local371)
+ }))(obj)).Bone) = string(local369)
if err := pcall(func() {
((*(*(struct {
ParentID AOID
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Vec", err))
}
- for local373 := range (*(*(struct {
+ for local371 := range (*(*(struct {
ParentID AOID
Bone string
Pos Vec
Pos Vec
Rot [3]float32
ForceVisible bool
- }))(obj)).Rot)[local373]
+ }))(obj)).Rot)[local371]
*p = math.Float32frombits(read32(r))
}
}
func (obj *TileDef) serialize(w io.Writer) {
{
- local374 := uint8(6)
+ local372 := uint8(6)
{
- x := local374
+ x := local372
write8(w, uint8(x))
}
}
func (obj *TileDef) deserialize(r io.Reader) {
{
- var local375 uint8
- local376 := uint8(6)
+ var local373 uint8
+ local374 := uint8(6)
{
- p := &local375
+ p := &local373
*p = read8(r)
}
- if local375 != local376 {
- chk(fmt.Errorf("const %v: %v", "uint8(6)", local375))
+ if local373 != local374 {
+ chk(fmt.Errorf("const %v: %v", "uint8(6)", local373))
}
}
if err := pcall(func() {
func (obj *NodeBox) serialize(w io.Writer) {
{
- local377 := uint8(6)
+ local375 := uint8(6)
{
- x := local377
+ x := local375
write8(w, uint8(x))
}
}
}))(obj)).Fixed)))
write16(w, uint16(x))
}
- for local378 := range (*(*(struct {
+ for local376 := range (*(*(struct {
Type NodeBoxType
//mt:if %s.Type == MountedBox
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).Fixed)[local378]).serialize(w)
+ }))(obj)).Fixed)[local376]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).DiscoAll)))
write16(w, uint16(x))
}
- for local379 := range (*(*(struct {
+ for local377 := range (*(*(struct {
Type NodeBoxType
//mt:if %s.Type == MountedBox
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).DiscoAll)[local379]).serialize(w)
+ }))(obj)).DiscoAll)[local377]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).DiscoSides)))
write16(w, uint16(x))
}
- for local380 := range (*(*(struct {
+ for local378 := range (*(*(struct {
Type NodeBoxType
//mt:if %s.Type == MountedBox
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).DiscoSides)[local380]).serialize(w)
+ }))(obj)).DiscoSides)[local378]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
func (obj *NodeBox) deserialize(r io.Reader) {
{
- var local381 uint8
- local382 := uint8(6)
+ var local379 uint8
+ local380 := uint8(6)
{
- p := &local381
+ p := &local379
*p = read8(r)
}
- if local381 != local382 {
- chk(fmt.Errorf("const %v: %v", "uint8(6)", local381))
+ if local379 != local380 {
+ chk(fmt.Errorf("const %v: %v", "uint8(6)", local379))
}
}
if err := pcall(func() {
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
}))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
- var local383 uint16
+ var local381 uint16
{
- p := &local383
+ p := &local381
*p = read16(r)
}
((*(*(struct {
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).Fixed) = make([]Box, local383)
- for local384 := range (*(*(struct {
+ }))(obj)).Fixed) = make([]Box, local381)
+ for local382 := range (*(*(struct {
Type NodeBoxType
//mt:if %s.Type == MountedBox
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).Fixed)[local384]).deserialize(r)
+ }))(obj)).Fixed)[local382]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.DirBoxes", err))
}
- var local385 uint16
+ var local383 uint16
{
- p := &local385
+ p := &local383
*p = read16(r)
}
((*(*(struct {
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).DiscoAll) = make([]Box, local385)
- for local386 := range (*(*(struct {
+ }))(obj)).DiscoAll) = make([]Box, local383)
+ for local384 := range (*(*(struct {
Type NodeBoxType
//mt:if %s.Type == MountedBox
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).DiscoAll)[local386]).deserialize(r)
+ }))(obj)).DiscoAll)[local384]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
}
}
- var local387 uint16
+ var local385 uint16
{
- p := &local387
+ p := &local385
*p = read16(r)
}
((*(*(struct {
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).DiscoSides) = make([]Box, local387)
- for local388 := range (*(*(struct {
+ }))(obj)).DiscoSides) = make([]Box, local385)
+ for local386 := range (*(*(struct {
Type NodeBoxType
//mt:if %s.Type == MountedBox
//mt:if %s.Type == ConnectedBox
ConnDirs, DiscoDirs DirBoxes
DiscoAll, DiscoSides []Box
- }))(obj)).DiscoSides)[local388]).deserialize(r)
+ }))(obj)).DiscoSides)[local386]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *SoundDef) deserialize(r io.Reader) {
- var local389 []uint8
- var local390 uint16
+ var local387 []uint8
+ var local388 uint16
{
- p := &local390
+ p := &local388
*p = read16(r)
}
- (local389) = make([]uint8, local390)
+ (local387) = make([]uint8, local388)
{
- _, err := io.ReadFull(r, (local389)[:])
+ _, err := io.ReadFull(r, (local387)[:])
chk(err)
}
((*(*(struct {
Name string
Gain, Pitch, Fade float32
- }))(obj)).Name) = string(local389)
+ }))(obj)).Name) = string(local387)
{
p := &(*(*(struct {
Name string
func (obj *AOInitData) serialize(w io.Writer) {
{
- local391 := uint8(1)
+ local389 := uint8(1)
{
- x := local391
+ x := local389
write8(w, uint8(x))
}
}
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
}
- for local392 := range (*(*(struct {
+ for local390 := range (*(*(struct {
// For players.
Name string
// See (de)serialize.fmt.
Msgs []AOMsg
- }))(obj)).Rot)[local392]
+ }))(obj)).Rot)[local390]
write32(w, math.Float32bits(x))
}
}
func (obj *AOInitData) deserialize(r io.Reader) {
{
- var local393 uint8
- local394 := uint8(1)
+ var local391 uint8
+ local392 := uint8(1)
{
- p := &local393
+ p := &local391
*p = read8(r)
}
- if local393 != local394 {
- chk(fmt.Errorf("const %v: %v", "uint8(1)", local393))
+ if local391 != local392 {
+ chk(fmt.Errorf("const %v: %v", "uint8(1)", local391))
}
}
- var local395 []uint8
- var local396 uint16
+ var local393 []uint8
+ var local394 uint16
{
- p := &local396
+ p := &local394
*p = read16(r)
}
- (local395) = make([]uint8, local396)
+ (local393) = make([]uint8, local394)
{
- _, err := io.ReadFull(r, (local395)[:])
+ _, err := io.ReadFull(r, (local393)[:])
chk(err)
}
((*(*(struct {
// See (de)serialize.fmt.
Msgs []AOMsg
- }))(obj)).Name) = string(local395)
+ }))(obj)).Name) = string(local393)
{
p := &(*(*(struct {
}
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Pos", err))
}
- for local397 := range (*(*(struct {
+ for local395 := range (*(*(struct {
// For players.
Name string
// See (de)serialize.fmt.
Msgs []AOMsg
- }))(obj)).Rot)[local397]
+ }))(obj)).Rot)[local395]
*p = math.Float32frombits(read32(r))
}
}
PunchUses int32
}))(obj)).NonNil {
{
- local398 := uint8(5)
+ local396 := uint8(5)
{
- x := local398
+ x := local396
write8(w, uint8(x))
}
}
}))(obj)).GroupCaps)))
write32(w, uint32(x))
}
- for local399 := range (*(*(struct {
+ for local397 := range (*(*(struct {
//mt:if _ = %s; false
NonNil bool
//mt:32tou16
PunchUses int32
- }))(obj)).GroupCaps)[local399]).serialize(w)
+ }))(obj)).GroupCaps)[local397]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).DmgGroups)))
write32(w, uint32(x))
}
- for local400 := range (*(*(struct {
+ for local398 := range (*(*(struct {
//mt:if _ = %s; false
NonNil bool
//mt:32tou16
PunchUses int32
- }))(obj)).DmgGroups)[local400]).serialize(w)
+ }))(obj)).DmgGroups)[local398]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
PunchUses int32
}))(obj)).NonNil {
{
- var local401 uint8
- local402 := uint8(5)
+ var local399 uint8
+ local400 := uint8(5)
{
- p := &local401
+ p := &local399
*p = read8(r)
}
- if local401 != local402 {
- chk(fmt.Errorf("const %v: %v", "uint8(5)", local401))
+ if local399 != local400 {
+ chk(fmt.Errorf("const %v: %v", "uint8(5)", local399))
}
}
{
}))(obj)).MaxDropLvl
*p = int16(read16(r))
}
- var local403 uint32
+ var local401 uint32
{
- p := &local403
+ p := &local401
*p = read32(r)
}
((*(*(struct {
//mt:32tou16
PunchUses int32
- }))(obj)).GroupCaps) = make([]ToolGroupCap, local403)
- for local404 := range (*(*(struct {
+ }))(obj)).GroupCaps) = make([]ToolGroupCap, local401)
+ for local402 := range (*(*(struct {
//mt:if _ = %s; false
NonNil bool
//mt:32tou16
PunchUses int32
- }))(obj)).GroupCaps)[local404]).deserialize(r)
+ }))(obj)).GroupCaps)[local402]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.ToolGroupCap", err))
}
}
- var local405 uint32
+ var local403 uint32
{
- p := &local405
+ p := &local403
*p = read32(r)
}
((*(*(struct {
//mt:32tou16
PunchUses int32
- }))(obj)).DmgGroups) = make([]Group, local405)
- for local406 := range (*(*(struct {
+ }))(obj)).DmgGroups) = make([]Group, local403)
+ for local404 := range (*(*(struct {
//mt:if _ = %s; false
NonNil bool
//mt:32tou16
PunchUses int32
- }))(obj)).DmgGroups)[local406]).deserialize(r)
+ }))(obj)).DmgGroups)[local404]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Group", err))
}
}
- var local407 uint16
+ var local405 uint16
{
- p := &local407
+ p := &local405
*p = read16(r)
}
(*(*(struct {
//mt:32tou16
PunchUses int32
- }))(obj)).PunchUses = int32(local407)
+ }))(obj)).PunchUses = int32(local405)
}
}
if r.N > 0 {
}
func (obj *Box) serialize(w io.Writer) {
- for local408 := range *(*([2]Vec))(obj) {
+ for local406 := range *(*([2]Vec))(obj) {
if err := pcall(func() {
- ((*(*([2]Vec))(obj))[local408]).serialize(w)
+ ((*(*([2]Vec))(obj))[local406]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *Box) deserialize(r io.Reader) {
- for local409 := range *(*([2]Vec))(obj) {
+ for local407 := range *(*([2]Vec))(obj) {
if err := pcall(func() {
- ((*(*([2]Vec))(obj))[local409]).deserialize(r)
+ ((*(*([2]Vec))(obj))[local407]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Top)))
write16(w, uint16(x))
}
- for local410 := range (*(*(struct {
+ for local408 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Top {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Top)[local410]).serialize(w)
+ }))(obj)).Top)[local408]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Bot)))
write16(w, uint16(x))
}
- for local411 := range (*(*(struct {
+ for local409 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Bot {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Bot)[local411]).serialize(w)
+ }))(obj)).Bot)[local409]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Front)))
write16(w, uint16(x))
}
- for local412 := range (*(*(struct {
+ for local410 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Front {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Front)[local412]).serialize(w)
+ }))(obj)).Front)[local410]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Left)))
write16(w, uint16(x))
}
- for local413 := range (*(*(struct {
+ for local411 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Left {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Left)[local413]).serialize(w)
+ }))(obj)).Left)[local411]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Back)))
write16(w, uint16(x))
}
- for local414 := range (*(*(struct {
+ for local412 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Back {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Back)[local414]).serialize(w)
+ }))(obj)).Back)[local412]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Right)))
write16(w, uint16(x))
}
- for local415 := range (*(*(struct {
+ for local413 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Right {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Right)[local415]).serialize(w)
+ }))(obj)).Right)[local413]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *DirBoxes) deserialize(r io.Reader) {
- var local416 uint16
+ var local414 uint16
{
- p := &local416
+ p := &local414
*p = read16(r)
}
((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Top) = make([]Box, local416)
- for local417 := range (*(*(struct {
+ }))(obj)).Top) = make([]Box, local414)
+ for local415 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Top {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Top)[local417]).deserialize(r)
+ }))(obj)).Top)[local415]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
}
}
- var local418 uint16
+ var local416 uint16
{
- p := &local418
+ p := &local416
*p = read16(r)
}
((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Bot) = make([]Box, local418)
- for local419 := range (*(*(struct {
+ }))(obj)).Bot) = make([]Box, local416)
+ for local417 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Bot {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Bot)[local419]).deserialize(r)
+ }))(obj)).Bot)[local417]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
}
}
- var local420 uint16
+ var local418 uint16
{
- p := &local420
+ p := &local418
*p = read16(r)
}
((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Front) = make([]Box, local420)
- for local421 := range (*(*(struct {
+ }))(obj)).Front) = make([]Box, local418)
+ for local419 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Front {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Front)[local421]).deserialize(r)
+ }))(obj)).Front)[local419]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
}
}
- var local422 uint16
+ var local420 uint16
{
- p := &local422
+ p := &local420
*p = read16(r)
}
((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Left) = make([]Box, local422)
- for local423 := range (*(*(struct {
+ }))(obj)).Left) = make([]Box, local420)
+ for local421 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Left {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Left)[local423]).deserialize(r)
+ }))(obj)).Left)[local421]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
}
}
- var local424 uint16
+ var local422 uint16
{
- p := &local424
+ p := &local422
*p = read16(r)
}
((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Back) = make([]Box, local424)
- for local425 := range (*(*(struct {
+ }))(obj)).Back) = make([]Box, local422)
+ for local423 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Back {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Back)[local425]).deserialize(r)
+ }))(obj)).Back)[local423]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
chk(fmt.Errorf("%s: %w", "github.com/anon55555/mt.Box", err))
}
}
- var local426 uint16
+ var local424 uint16
{
- p := &local426
+ p := &local424
*p = read16(r)
}
((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Right) = make([]Box, local426)
- for local427 := range (*(*(struct {
+ }))(obj)).Right) = make([]Box, local424)
+ for local425 := range (*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
}))(obj)).Right {
(((*(*(struct {
Top, Bot []Box
Front, Left, Back, Right []Box
- }))(obj)).Right)[local427]).deserialize(r)
+ }))(obj)).Right)[local425]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}))(obj)).Times)))
write32(w, uint32(x))
}
- for local428 := range (*(*(struct {
+ for local426 := range (*(*(struct {
Name string
//mt:32to16
//mt:len32
Times []DigTime
- }))(obj)).Times)[local428]).serialize(w)
+ }))(obj)).Times)[local426]).serialize(w)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
}
func (obj *ToolGroupCap) deserialize(r io.Reader) {
- var local429 []uint8
- var local430 uint16
+ var local427 []uint8
+ var local428 uint16
{
- p := &local430
+ p := &local428
*p = read16(r)
}
- (local429) = make([]uint8, local430)
+ (local427) = make([]uint8, local428)
{
- _, err := io.ReadFull(r, (local429)[:])
+ _, err := io.ReadFull(r, (local427)[:])
chk(err)
}
((*(*(struct {
//mt:len32
Times []DigTime
- }))(obj)).Name) = string(local429)
- var local431 int16
+ }))(obj)).Name) = string(local427)
+ var local429 int16
{
- p := &local431
+ p := &local429
*p = int16(read16(r))
}
(*(*(struct {
//mt:len32
Times []DigTime
- }))(obj)).Uses = int32(local431)
+ }))(obj)).Uses = int32(local429)
{
p := &(*(*(struct {
Name string
}))(obj)).MaxLvl
*p = int16(read16(r))
}
- var local432 uint32
+ var local430 uint32
{
- p := &local432
+ p := &local430
*p = read32(r)
}
((*(*(struct {
//mt:len32
Times []DigTime
- }))(obj)).Times) = make([]DigTime, local432)
- for local433 := range (*(*(struct {
+ }))(obj)).Times) = make([]DigTime, local430)
+ for local431 := range (*(*(struct {
Name string
//mt:32to16
//mt:len32
Times []DigTime
- }))(obj)).Times)[local433]).deserialize(r)
+ }))(obj)).Times)[local431]).deserialize(r)
}); err != nil {
if err == io.EOF {
chk(io.EOF)
projects / mt.git / commitdiff