serialize.go

   1 // Code generated by mkserialize.sh; DO NOT EDIT.
   2
   3 package mt
   4
   5 import (
   6         "bytes"
   7         "compress/zlib"
   8         "errors"
   9         "fmt"
  10         "image/color"
  11         "io"
  12         "math"
  13         "sort"
  14         "unicode/utf16"
  15
  16         "github.com/klauspost/compress/zstd"
  17 )
  18
  19 func write8(w io.Writer, x uint8) {
  20         _, err := w.Write([]byte{x})
  21         chk(err)
  22 }
  23 func write16(w io.Writer, x uint16) {
  24         buf := make([]byte, 2)
  25         be.PutUint16(buf, x)
  26         _, err := w.Write(buf)
  27         chk(err)
  28 }
  29 func write32(w io.Writer, x uint32) {
  30         buf := make([]byte, 4)
  31         be.PutUint32(buf, x)
  32         _, err := w.Write(buf)
  33         chk(err)
  34 }
  35 func write64(w io.Writer, x uint64) {
  36         buf := make([]byte, 8)
  37         be.PutUint64(buf, x)
  38         _, err := w.Write(buf)
  39         chk(err)
  40 }
  41 func readBuf(r io.Reader, n int) []byte {
  42         buf := make([]byte, n)
  43         _, err := io.ReadFull(r, buf)
  44         chk(err)
  45         return buf
  46 }
  47 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  48 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  49 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  50 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  51
  52 func (obj *ToSrvNil) serialize(w io.Writer) {
  53 }
  54
  55 func (obj *ToSrvNil) deserialize(r io.Reader) {
  56 }
  57
  58 func (obj *ToSrvInit) serialize(w io.Writer) {
  59         {
  60                 x := (*(*(struct {
  61                         SerializeVer             uint8
  62                         SupportedCompression     CompressionModes
  63                         MinProtoVer, MaxProtoVer uint16
  64                         PlayerName               string
  65
  66                         //mt:opt
  67                         SendFullItemMeta bool
  68                 }))(obj)).SerializeVer
  69                 write8(w, uint8(x))
  70         }
  71         if err := pcall(func() {
  72                 ((*(*(struct {
  73                         SerializeVer             uint8
  74                         SupportedCompression     CompressionModes
  75                         MinProtoVer, MaxProtoVer uint16
  76                         PlayerName               string
  77
  78                         //mt:opt
  79                         SendFullItemMeta bool
  80                 }))(obj)).SupportedCompression).serialize(w)
  81         }); err != nil {
  82                 if err == io.EOF {
  83                         chk(io.EOF)
  84                 }
  85                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
  86         }
  87         {
  88                 x := (*(*(struct {
  89                         SerializeVer             uint8
  90                         SupportedCompression     CompressionModes
  91                         MinProtoVer, MaxProtoVer uint16
  92                         PlayerName               string
  93
  94                         //mt:opt
  95                         SendFullItemMeta bool
  96                 }))(obj)).MinProtoVer
  97                 write16(w, uint16(x))
  98         }
  99         {
 100                 x := (*(*(struct {
 101                         SerializeVer             uint8
 102                         SupportedCompression     CompressionModes
 103                         MinProtoVer, MaxProtoVer uint16
 104                         PlayerName               string
 105
 106                         //mt:opt
 107                         SendFullItemMeta bool
 108                 }))(obj)).MaxProtoVer
 109                 write16(w, uint16(x))
 110         }
 111         if len(([]byte((*(*(struct {
 112                 SerializeVer             uint8
 113                 SupportedCompression     CompressionModes
 114                 MinProtoVer, MaxProtoVer uint16
 115                 PlayerName               string
 116
 117                 //mt:opt
 118                 SendFullItemMeta bool
 119         }))(obj)).PlayerName))) > math.MaxUint16 {
 120                 chk(ErrTooLong)
 121         }
 122         {
 123                 x := uint16(len(([]byte((*(*(struct {
 124                         SerializeVer             uint8
 125                         SupportedCompression     CompressionModes
 126                         MinProtoVer, MaxProtoVer uint16
 127                         PlayerName               string
 128
 129                         //mt:opt
 130                         SendFullItemMeta bool
 131                 }))(obj)).PlayerName))))
 132                 write16(w, uint16(x))
 133         }
 134         {
 135                 _, err := w.Write(([]byte((*(*(struct {
 136                         SerializeVer             uint8
 137                         SupportedCompression     CompressionModes
 138                         MinProtoVer, MaxProtoVer uint16
 139                         PlayerName               string
 140
 141                         //mt:opt
 142                         SendFullItemMeta bool
 143                 }))(obj)).PlayerName))[:])
 144                 chk(err)
 145         }
 146         if err := pcall(func() {
 147                 {
 148                         x := (*(*(struct {
 149                                 SerializeVer             uint8
 150                                 SupportedCompression     CompressionModes
 151                                 MinProtoVer, MaxProtoVer uint16
 152                                 PlayerName               string
 153
 154                                 //mt:opt
 155                                 SendFullItemMeta bool
 156                         }))(obj)).SendFullItemMeta
 157                         if x {
 158                                 write8(w, 1)
 159                         } else {
 160                                 write8(w, 0)
 161                         }
 162                 }
 163         }); err != nil && err != io.EOF {
 164                 chk(err)
 165         }
 166 }
 167
 168 func (obj *ToSrvInit) deserialize(r io.Reader) {
 169         {
 170                 p := &(*(*(struct {
 171                         SerializeVer             uint8
 172                         SupportedCompression     CompressionModes
 173                         MinProtoVer, MaxProtoVer uint16
 174                         PlayerName               string
 175
 176                         //mt:opt
 177                         SendFullItemMeta bool
 178                 }))(obj)).SerializeVer
 179                 *p = read8(r)
 180         }
 181         if err := pcall(func() {
 182                 ((*(*(struct {
 183                         SerializeVer             uint8
 184                         SupportedCompression     CompressionModes
 185                         MinProtoVer, MaxProtoVer uint16
 186                         PlayerName               string
 187
 188                         //mt:opt
 189                         SendFullItemMeta bool
 190                 }))(obj)).SupportedCompression).deserialize(r)
 191         }); err != nil {
 192                 if err == io.EOF {
 193                         chk(io.EOF)
 194                 }
 195                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
 196         }
 197         {
 198                 p := &(*(*(struct {
 199                         SerializeVer             uint8
 200                         SupportedCompression     CompressionModes
 201                         MinProtoVer, MaxProtoVer uint16
 202                         PlayerName               string
 203
 204                         //mt:opt
 205                         SendFullItemMeta bool
 206                 }))(obj)).MinProtoVer
 207                 *p = read16(r)
 208         }
 209         {
 210                 p := &(*(*(struct {
 211                         SerializeVer             uint8
 212                         SupportedCompression     CompressionModes
 213                         MinProtoVer, MaxProtoVer uint16
 214                         PlayerName               string
 215
 216                         //mt:opt
 217                         SendFullItemMeta bool
 218                 }))(obj)).MaxProtoVer
 219                 *p = read16(r)
 220         }
 221         var local1 []uint8
 222         var local2 uint16
 223         {
 224                 p := &local2
 225                 *p = read16(r)
 226         }
 227         (local1) = make([]uint8, local2)
 228         {
 229                 _, err := io.ReadFull(r, (local1)[:])
 230                 chk(err)
 231         }
 232         ((*(*(struct {
 233                 SerializeVer             uint8
 234                 SupportedCompression     CompressionModes
 235                 MinProtoVer, MaxProtoVer uint16
 236                 PlayerName               string
 237
 238                 //mt:opt
 239                 SendFullItemMeta bool
 240         }))(obj)).PlayerName) = string(local1)
 241         if err := pcall(func() {
 242                 {
 243                         p := &(*(*(struct {
 244                                 SerializeVer             uint8
 245                                 SupportedCompression     CompressionModes
 246                                 MinProtoVer, MaxProtoVer uint16
 247                                 PlayerName               string
 248
 249                                 //mt:opt
 250                                 SendFullItemMeta bool
 251                         }))(obj)).SendFullItemMeta
 252                         switch n := read8(r); n {
 253                         case 0:
 254                                 *p = false
 255                         case 1:
 256                                 *p = true
 257                         default:
 258                                 chk(fmt.Errorf("invalid bool: %d", n))
 259                         }
 260                 }
 261         }); err != nil && err != io.EOF {
 262                 chk(err)
 263         }
 264 }
 265
 266 func (obj *ToSrvInit2) serialize(w io.Writer) {
 267         if len(([]byte((*(*(struct {
 268                 Lang string
 269         }))(obj)).Lang))) > math.MaxUint16 {
 270                 chk(ErrTooLong)
 271         }
 272         {
 273                 x := uint16(len(([]byte((*(*(struct {
 274                         Lang string
 275                 }))(obj)).Lang))))
 276                 write16(w, uint16(x))
 277         }
 278         {
 279                 _, err := w.Write(([]byte((*(*(struct {
 280                         Lang string
 281                 }))(obj)).Lang))[:])
 282                 chk(err)
 283         }
 284 }
 285
 286 func (obj *ToSrvInit2) deserialize(r io.Reader) {
 287         var local3 []uint8
 288         var local4 uint16
 289         {
 290                 p := &local4
 291                 *p = read16(r)
 292         }
 293         (local3) = make([]uint8, local4)
 294         {
 295                 _, err := io.ReadFull(r, (local3)[:])
 296                 chk(err)
 297         }
 298         ((*(*(struct {
 299                 Lang string
 300         }))(obj)).Lang) = string(local3)
 301 }
 302
 303 func (obj *ToSrvJoinModChan) serialize(w io.Writer) {
 304         if len(([]byte((*(*(struct {
 305                 Channel string
 306         }))(obj)).Channel))) > math.MaxUint16 {
 307                 chk(ErrTooLong)
 308         }
 309         {
 310                 x := uint16(len(([]byte((*(*(struct {
 311                         Channel string
 312                 }))(obj)).Channel))))
 313                 write16(w, uint16(x))
 314         }
 315         {
 316                 _, err := w.Write(([]byte((*(*(struct {
 317                         Channel string
 318                 }))(obj)).Channel))[:])
 319                 chk(err)
 320         }
 321 }
 322
 323 func (obj *ToSrvJoinModChan) deserialize(r io.Reader) {
 324         var local5 []uint8
 325         var local6 uint16
 326         {
 327                 p := &local6
 328                 *p = read16(r)
 329         }
 330         (local5) = make([]uint8, local6)
 331         {
 332                 _, err := io.ReadFull(r, (local5)[:])
 333                 chk(err)
 334         }
 335         ((*(*(struct {
 336                 Channel string
 337         }))(obj)).Channel) = string(local5)
 338 }
 339
 340 func (obj *ToSrvLeaveModChan) serialize(w io.Writer) {
 341         if len(([]byte((*(*(struct {
 342                 Channel string
 343         }))(obj)).Channel))) > math.MaxUint16 {
 344                 chk(ErrTooLong)
 345         }
 346         {
 347                 x := uint16(len(([]byte((*(*(struct {
 348                         Channel string
 349                 }))(obj)).Channel))))
 350                 write16(w, uint16(x))
 351         }
 352         {
 353                 _, err := w.Write(([]byte((*(*(struct {
 354                         Channel string
 355                 }))(obj)).Channel))[:])
 356                 chk(err)
 357         }
 358 }
 359
 360 func (obj *ToSrvLeaveModChan) deserialize(r io.Reader) {
 361         var local7 []uint8
 362         var local8 uint16
 363         {
 364                 p := &local8
 365                 *p = read16(r)
 366         }
 367         (local7) = make([]uint8, local8)
 368         {
 369                 _, err := io.ReadFull(r, (local7)[:])
 370                 chk(err)
 371         }
 372         ((*(*(struct {
 373                 Channel string
 374         }))(obj)).Channel) = string(local7)
 375 }
 376
 377 func (obj *ToSrvMsgModChan) serialize(w io.Writer) {
 378         if len(([]byte((*(*(struct {
 379                 Channel string
 380                 Msg     string
 381         }))(obj)).Channel))) > math.MaxUint16 {
 382                 chk(ErrTooLong)
 383         }
 384         {
 385                 x := uint16(len(([]byte((*(*(struct {
 386                         Channel string
 387                         Msg     string
 388                 }))(obj)).Channel))))
 389                 write16(w, uint16(x))
 390         }
 391         {
 392                 _, err := w.Write(([]byte((*(*(struct {
 393                         Channel string
 394                         Msg     string
 395                 }))(obj)).Channel))[:])
 396                 chk(err)
 397         }
 398         if len(([]byte((*(*(struct {
 399                 Channel string
 400                 Msg     string
 401         }))(obj)).Msg))) > math.MaxUint16 {
 402                 chk(ErrTooLong)
 403         }
 404         {
 405                 x := uint16(len(([]byte((*(*(struct {
 406                         Channel string
 407                         Msg     string
 408                 }))(obj)).Msg))))
 409                 write16(w, uint16(x))
 410         }
 411         {
 412                 _, err := w.Write(([]byte((*(*(struct {
 413                         Channel string
 414                         Msg     string
 415                 }))(obj)).Msg))[:])
 416                 chk(err)
 417         }
 418 }
 419
 420 func (obj *ToSrvMsgModChan) deserialize(r io.Reader) {
 421         var local9 []uint8
 422         var local10 uint16
 423         {
 424                 p := &local10
 425                 *p = read16(r)
 426         }
 427         (local9) = make([]uint8, local10)
 428         {
 429                 _, err := io.ReadFull(r, (local9)[:])
 430                 chk(err)
 431         }
 432         ((*(*(struct {
 433                 Channel string
 434                 Msg     string
 435         }))(obj)).Channel) = string(local9)
 436         var local11 []uint8
 437         var local12 uint16
 438         {
 439                 p := &local12
 440                 *p = read16(r)
 441         }
 442         (local11) = make([]uint8, local12)
 443         {
 444                 _, err := io.ReadFull(r, (local11)[:])
 445                 chk(err)
 446         }
 447         ((*(*(struct {
 448                 Channel string
 449                 Msg     string
 450         }))(obj)).Msg) = string(local11)
 451 }
 452
 453 func (obj *ToSrvPlayerPos) serialize(w io.Writer) {
 454         if err := pcall(func() {
 455                 ((*(*(struct {
 456                         Pos PlayerPos
 457                 }))(obj)).Pos).serialize(w)
 458         }); err != nil {
 459                 if err == io.EOF {
 460                         chk(io.EOF)
 461                 }
 462                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 463         }
 464 }
 465
 466 func (obj *ToSrvPlayerPos) deserialize(r io.Reader) {
 467         if err := pcall(func() {
 468                 ((*(*(struct {
 469                         Pos PlayerPos
 470                 }))(obj)).Pos).deserialize(r)
 471         }); err != nil {
 472                 if err == io.EOF {
 473                         chk(io.EOF)
 474                 }
 475                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 476         }
 477 }
 478
 479 func (obj *ToSrvGotBlks) serialize(w io.Writer) {
 480         if len(((*(*(struct {
 481                 //mt:len8
 482                 Blks [][3]int16
 483         }))(obj)).Blks)) > math.MaxUint8 {
 484                 chk(ErrTooLong)
 485         }
 486         {
 487                 x := uint8(len(((*(*(struct {
 488                         //mt:len8
 489                         Blks [][3]int16
 490                 }))(obj)).Blks)))
 491                 write8(w, uint8(x))
 492         }
 493         for local13 := range (*(*(struct {
 494                 //mt:len8
 495                 Blks [][3]int16
 496         }))(obj)).Blks {
 497                 for local14 := range ((*(*(struct {
 498                         //mt:len8
 499                         Blks [][3]int16
 500                 }))(obj)).Blks)[local13] {
 501                         {
 502                                 x := (((*(*(struct {
 503                                         //mt:len8
 504                                         Blks [][3]int16
 505                                 }))(obj)).Blks)[local13])[local14]
 506                                 write16(w, uint16(x))
 507                         }
 508                 }
 509         }
 510 }
 511
 512 func (obj *ToSrvGotBlks) deserialize(r io.Reader) {
 513         var local15 uint8
 514         {
 515                 p := &local15
 516                 *p = read8(r)
 517         }
 518         ((*(*(struct {
 519                 //mt:len8
 520                 Blks [][3]int16
 521         }))(obj)).Blks) = make([][3]int16, local15)
 522         for local16 := range (*(*(struct {
 523                 //mt:len8
 524                 Blks [][3]int16
 525         }))(obj)).Blks {
 526                 for local17 := range ((*(*(struct {
 527                         //mt:len8
 528                         Blks [][3]int16
 529                 }))(obj)).Blks)[local16] {
 530                         {
 531                                 p := &(((*(*(struct {
 532                                         //mt:len8
 533                                         Blks [][3]int16
 534                                 }))(obj)).Blks)[local16])[local17]
 535                                 *p = int16(read16(r))
 536                         }
 537                 }
 538         }
 539 }
 540
 541 func (obj *ToSrvDeletedBlks) serialize(w io.Writer) {
 542         if len(((*(*(struct {
 543                 //mt:len8
 544                 Blks [][3]int16
 545         }))(obj)).Blks)) > math.MaxUint8 {
 546                 chk(ErrTooLong)
 547         }
 548         {
 549                 x := uint8(len(((*(*(struct {
 550                         //mt:len8
 551                         Blks [][3]int16
 552                 }))(obj)).Blks)))
 553                 write8(w, uint8(x))
 554         }
 555         for local18 := range (*(*(struct {
 556                 //mt:len8
 557                 Blks [][3]int16
 558         }))(obj)).Blks {
 559                 for local19 := range ((*(*(struct {
 560                         //mt:len8
 561                         Blks [][3]int16
 562                 }))(obj)).Blks)[local18] {
 563                         {
 564                                 x := (((*(*(struct {
 565                                         //mt:len8
 566                                         Blks [][3]int16
 567                                 }))(obj)).Blks)[local18])[local19]
 568                                 write16(w, uint16(x))
 569                         }
 570                 }
 571         }
 572 }
 573
 574 func (obj *ToSrvDeletedBlks) deserialize(r io.Reader) {
 575         var local20 uint8
 576         {
 577                 p := &local20
 578                 *p = read8(r)
 579         }
 580         ((*(*(struct {
 581                 //mt:len8
 582                 Blks [][3]int16
 583         }))(obj)).Blks) = make([][3]int16, local20)
 584         for local21 := range (*(*(struct {
 585                 //mt:len8
 586                 Blks [][3]int16
 587         }))(obj)).Blks {
 588                 for local22 := range ((*(*(struct {
 589                         //mt:len8
 590                         Blks [][3]int16
 591                 }))(obj)).Blks)[local21] {
 592                         {
 593                                 p := &(((*(*(struct {
 594                                         //mt:len8
 595                                         Blks [][3]int16
 596                                 }))(obj)).Blks)[local21])[local22]
 597                                 *p = int16(read16(r))
 598                         }
 599                 }
 600         }
 601 }
 602
 603 func (obj *ToSrvInvAction) serialize(w io.Writer) {
 604         {
 605                 _, err := w.Write(([]byte((*(*(struct {
 606                         //mt:raw
 607                         Action string
 608                 }))(obj)).Action))[:])
 609                 chk(err)
 610         }
 611 }
 612
 613 func (obj *ToSrvInvAction) deserialize(r io.Reader) {
 614         var local23 []uint8
 615         {
 616                 var err error
 617                 (local23), err = io.ReadAll(r)
 618                 chk(err)
 619         }
 620         ((*(*(struct {
 621                 //mt:raw
 622                 Action string
 623         }))(obj)).Action) = string(local23)
 624 }
 625
 626 func (obj *ToSrvChatMsg) serialize(w io.Writer) {
 627         local24 := utf16.Encode([]rune((*(*(struct {
 628                 //mt:utf16
 629                 Msg string
 630         }))(obj)).Msg))
 631         if len((local24)) > math.MaxUint16 {
 632                 chk(ErrTooLong)
 633         }
 634         {
 635                 x := uint16(len((local24)))
 636                 write16(w, uint16(x))
 637         }
 638         for local25 := range local24 {
 639                 {
 640                         x := (local24)[local25]
 641                         write16(w, uint16(x))
 642                 }
 643         }
 644 }
 645
 646 func (obj *ToSrvChatMsg) deserialize(r io.Reader) {
 647         var local26 []uint16
 648         var local27 uint16
 649         {
 650                 p := &local27
 651                 *p = read16(r)
 652         }
 653         (local26) = make([]uint16, local27)
 654         for local28 := range local26 {
 655                 {
 656                         p := &(local26)[local28]
 657                         *p = read16(r)
 658                 }
 659         }
 660         (*(*(struct {
 661                 //mt:utf16
 662                 Msg string
 663         }))(obj)).Msg = string(utf16.Decode(local26))
 664 }
 665
 666 func (obj *ToSrvFallDmg) serialize(w io.Writer) {
 667         {
 668                 x := (*(*(struct {
 669                         Amount uint16
 670                 }))(obj)).Amount
 671                 write16(w, uint16(x))
 672         }
 673 }
 674
 675 func (obj *ToSrvFallDmg) deserialize(r io.Reader) {
 676         {
 677                 p := &(*(*(struct {
 678                         Amount uint16
 679                 }))(obj)).Amount
 680                 *p = read16(r)
 681         }
 682 }
 683
 684 func (obj *ToSrvSelectItem) serialize(w io.Writer) {
 685         {
 686                 x := (*(*(struct {
 687                         Slot uint16
 688                 }))(obj)).Slot
 689                 write16(w, uint16(x))
 690         }
 691 }
 692
 693 func (obj *ToSrvSelectItem) deserialize(r io.Reader) {
 694         {
 695                 p := &(*(*(struct {
 696                         Slot uint16
 697                 }))(obj)).Slot
 698                 *p = read16(r)
 699         }
 700 }
 701
 702 func (obj *ToSrvRespawn) serialize(w io.Writer) {
 703 }
 704
 705 func (obj *ToSrvRespawn) deserialize(r io.Reader) {
 706 }
 707
 708 func (obj *ToSrvInteract) serialize(w io.Writer) {
 709         if err := pcall(func() {
 710                 ((*(*(struct {
 711                         Action   Interaction
 712                         ItemSlot uint16
 713                         //mt:lenhdr 32
 714                         Pointed PointedThing
 715                         //mt:end
 716                         Pos PlayerPos
 717                 }))(obj)).Action).serialize(w)
 718         }); err != nil {
 719                 if err == io.EOF {
 720                         chk(io.EOF)
 721                 }
 722                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Interaction", err))
 723         }
 724         {
 725                 x := (*(*(struct {
 726                         Action   Interaction
 727                         ItemSlot uint16
 728                         //mt:lenhdr 32
 729                         Pointed PointedThing
 730                         //mt:end
 731                         Pos PlayerPos
 732                 }))(obj)).ItemSlot
 733                 write16(w, uint16(x))
 734         }
 735         {
 736                 ow := w
 737                 w := new(bytes.Buffer)
 738                 {
 739                         x := (*(*(struct {
 740                                 Action   Interaction
 741                                 ItemSlot uint16
 742                                 //mt:lenhdr 32
 743                                 Pointed PointedThing
 744                                 //mt:end
 745                                 Pos PlayerPos
 746                         }))(obj)).Pointed
 747                         chk(writePointedThing(w, x))
 748                 }
 749                 {
 750                         buf := w
 751                         w := ow
 752                         if len((buf.Bytes())) > math.MaxUint32 {
 753                                 chk(ErrTooLong)
 754                         }
 755                         {
 756                                 x := uint32(len((buf.Bytes())))
 757                                 write32(w, uint32(x))
 758                         }
 759                         {
 760                                 _, err := w.Write((buf.Bytes())[:])
 761                                 chk(err)
 762                         }
 763                 }
 764         }
 765         if err := pcall(func() {
 766                 ((*(*(struct {
 767                         Action   Interaction
 768                         ItemSlot uint16
 769                         //mt:lenhdr 32
 770                         Pointed PointedThing
 771                         //mt:end
 772                         Pos PlayerPos
 773                 }))(obj)).Pos).serialize(w)
 774         }); err != nil {
 775                 if err == io.EOF {
 776                         chk(io.EOF)
 777                 }
 778                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 779         }
 780 }
 781
 782 func (obj *ToSrvInteract) deserialize(r io.Reader) {
 783         if err := pcall(func() {
 784                 ((*(*(struct {
 785                         Action   Interaction
 786                         ItemSlot uint16
 787                         //mt:lenhdr 32
 788                         Pointed PointedThing
 789                         //mt:end
 790                         Pos PlayerPos
 791                 }))(obj)).Action).deserialize(r)
 792         }); err != nil {
 793                 if err == io.EOF {
 794                         chk(io.EOF)
 795                 }
 796                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Interaction", err))
 797         }
 798         {
 799                 p := &(*(*(struct {
 800                         Action   Interaction
 801                         ItemSlot uint16
 802                         //mt:lenhdr 32
 803                         Pointed PointedThing
 804                         //mt:end
 805                         Pos PlayerPos
 806                 }))(obj)).ItemSlot
 807                 *p = read16(r)
 808         }
 809         {
 810                 var n uint32
 811                 {
 812                         p := &n
 813                         *p = read32(r)
 814                 }
 815                 r := &io.LimitedReader{R: r, N: int64(n)}
 816                 {
 817                         p := &(*(*(struct {
 818                                 Action   Interaction
 819                                 ItemSlot uint16
 820                                 //mt:lenhdr 32
 821                                 Pointed PointedThing
 822                                 //mt:end
 823                                 Pos PlayerPos
 824                         }))(obj)).Pointed
 825                         {
 826                                 var err error
 827                                 *p, err = readPointedThing(r)
 828                                 chk(err)
 829                         }
 830                 }
 831                 if r.N > 0 {
 832                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 833                 }
 834         }
 835         if err := pcall(func() {
 836                 ((*(*(struct {
 837                         Action   Interaction
 838                         ItemSlot uint16
 839                         //mt:lenhdr 32
 840                         Pointed PointedThing
 841                         //mt:end
 842                         Pos PlayerPos
 843                 }))(obj)).Pos).deserialize(r)
 844         }); err != nil {
 845                 if err == io.EOF {
 846                         chk(io.EOF)
 847                 }
 848                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 849         }
 850 }
 851
 852 func (obj *ToSrvRemovedSounds) serialize(w io.Writer) {
 853         if len(((*(*(struct {
 854                 IDs []SoundID
 855         }))(obj)).IDs)) > math.MaxUint16 {
 856                 chk(ErrTooLong)
 857         }
 858         {
 859                 x := uint16(len(((*(*(struct {
 860                         IDs []SoundID
 861                 }))(obj)).IDs)))
 862                 write16(w, uint16(x))
 863         }
 864         for local29 := range (*(*(struct {
 865                 IDs []SoundID
 866         }))(obj)).IDs {
 867                 if err := pcall(func() {
 868                         (((*(*(struct {
 869                                 IDs []SoundID
 870                         }))(obj)).IDs)[local29]).serialize(w)
 871                 }); err != nil {
 872                         if err == io.EOF {
 873                                 chk(io.EOF)
 874                         }
 875                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
 876                 }
 877         }
 878 }
 879
 880 func (obj *ToSrvRemovedSounds) deserialize(r io.Reader) {
 881         var local30 uint16
 882         {
 883                 p := &local30
 884                 *p = read16(r)
 885         }
 886         ((*(*(struct {
 887                 IDs []SoundID
 888         }))(obj)).IDs) = make([]SoundID, local30)
 889         for local31 := range (*(*(struct {
 890                 IDs []SoundID
 891         }))(obj)).IDs {
 892                 if err := pcall(func() {
 893                         (((*(*(struct {
 894                                 IDs []SoundID
 895                         }))(obj)).IDs)[local31]).deserialize(r)
 896                 }); err != nil {
 897                         if err == io.EOF {
 898                                 chk(io.EOF)
 899                         }
 900                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
 901                 }
 902         }
 903 }
 904
 905 func (obj *ToSrvNodeMetaFields) serialize(w io.Writer) {
 906         for local32 := range (*(*(struct {
 907                 Pos      [3]int16
 908                 Formname string
 909                 Fields   []Field
 910         }))(obj)).Pos {
 911                 {
 912                         x := ((*(*(struct {
 913                                 Pos      [3]int16
 914                                 Formname string
 915                                 Fields   []Field
 916                         }))(obj)).Pos)[local32]
 917                         write16(w, uint16(x))
 918                 }
 919         }
 920         if len(([]byte((*(*(struct {
 921                 Pos      [3]int16
 922                 Formname string
 923                 Fields   []Field
 924         }))(obj)).Formname))) > math.MaxUint16 {
 925                 chk(ErrTooLong)
 926         }
 927         {
 928                 x := uint16(len(([]byte((*(*(struct {
 929                         Pos      [3]int16
 930                         Formname string
 931                         Fields   []Field
 932                 }))(obj)).Formname))))
 933                 write16(w, uint16(x))
 934         }
 935         {
 936                 _, err := w.Write(([]byte((*(*(struct {
 937                         Pos      [3]int16
 938                         Formname string
 939                         Fields   []Field
 940                 }))(obj)).Formname))[:])
 941                 chk(err)
 942         }
 943         if len(((*(*(struct {
 944                 Pos      [3]int16
 945                 Formname string
 946                 Fields   []Field
 947         }))(obj)).Fields)) > math.MaxUint16 {
 948                 chk(ErrTooLong)
 949         }
 950         {
 951                 x := uint16(len(((*(*(struct {
 952                         Pos      [3]int16
 953                         Formname string
 954                         Fields   []Field
 955                 }))(obj)).Fields)))
 956                 write16(w, uint16(x))
 957         }
 958         for local33 := range (*(*(struct {
 959                 Pos      [3]int16
 960                 Formname string
 961                 Fields   []Field
 962         }))(obj)).Fields {
 963                 if err := pcall(func() {
 964                         (((*(*(struct {
 965                                 Pos      [3]int16
 966                                 Formname string
 967                                 Fields   []Field
 968                         }))(obj)).Fields)[local33]).serialize(w)
 969                 }); err != nil {
 970                         if err == io.EOF {
 971                                 chk(io.EOF)
 972                         }
 973                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
 974                 }
 975         }
 976 }
 977
 978 func (obj *ToSrvNodeMetaFields) deserialize(r io.Reader) {
 979         for local34 := range (*(*(struct {
 980                 Pos      [3]int16
 981                 Formname string
 982                 Fields   []Field
 983         }))(obj)).Pos {
 984                 {
 985                         p := &((*(*(struct {
 986                                 Pos      [3]int16
 987                                 Formname string
 988                                 Fields   []Field
 989                         }))(obj)).Pos)[local34]
 990                         *p = int16(read16(r))
 991                 }
 992         }
 993         var local35 []uint8
 994         var local36 uint16
 995         {
 996                 p := &local36
 997                 *p = read16(r)
 998         }
 999         (local35) = make([]uint8, local36)
1000         {
1001                 _, err := io.ReadFull(r, (local35)[:])
1002                 chk(err)
1003         }
1004         ((*(*(struct {
1005                 Pos      [3]int16
1006                 Formname string
1007                 Fields   []Field
1008         }))(obj)).Formname) = string(local35)
1009         var local37 uint16
1010         {
1011                 p := &local37
1012                 *p = read16(r)
1013         }
1014         ((*(*(struct {
1015                 Pos      [3]int16
1016                 Formname string
1017                 Fields   []Field
1018         }))(obj)).Fields) = make([]Field, local37)
1019         for local38 := range (*(*(struct {
1020                 Pos      [3]int16
1021                 Formname string
1022                 Fields   []Field
1023         }))(obj)).Fields {
1024                 if err := pcall(func() {
1025                         (((*(*(struct {
1026                                 Pos      [3]int16
1027                                 Formname string
1028                                 Fields   []Field
1029                         }))(obj)).Fields)[local38]).deserialize(r)
1030                 }); err != nil {
1031                         if err == io.EOF {
1032                                 chk(io.EOF)
1033                         }
1034                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
1035                 }
1036         }
1037 }
1038
1039 func (obj *ToSrvInvFields) serialize(w io.Writer) {
1040         if len(([]byte((*(*(struct {
1041                 Formname string
1042                 Fields   []Field
1043         }))(obj)).Formname))) > math.MaxUint16 {
1044                 chk(ErrTooLong)
1045         }
1046         {
1047                 x := uint16(len(([]byte((*(*(struct {
1048                         Formname string
1049                         Fields   []Field
1050                 }))(obj)).Formname))))
1051                 write16(w, uint16(x))
1052         }
1053         {
1054                 _, err := w.Write(([]byte((*(*(struct {
1055                         Formname string
1056                         Fields   []Field
1057                 }))(obj)).Formname))[:])
1058                 chk(err)
1059         }
1060         if len(((*(*(struct {
1061                 Formname string
1062                 Fields   []Field
1063         }))(obj)).Fields)) > math.MaxUint16 {
1064                 chk(ErrTooLong)
1065         }
1066         {
1067                 x := uint16(len(((*(*(struct {
1068                         Formname string
1069                         Fields   []Field
1070                 }))(obj)).Fields)))
1071                 write16(w, uint16(x))
1072         }
1073         for local39 := range (*(*(struct {
1074                 Formname string
1075                 Fields   []Field
1076         }))(obj)).Fields {
1077                 if err := pcall(func() {
1078                         (((*(*(struct {
1079                                 Formname string
1080                                 Fields   []Field
1081                         }))(obj)).Fields)[local39]).serialize(w)
1082                 }); err != nil {
1083                         if err == io.EOF {
1084                                 chk(io.EOF)
1085                         }
1086                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
1087                 }
1088         }
1089 }
1090
1091 func (obj *ToSrvInvFields) deserialize(r io.Reader) {
1092         var local40 []uint8
1093         var local41 uint16
1094         {
1095                 p := &local41
1096                 *p = read16(r)
1097         }
1098         (local40) = make([]uint8, local41)
1099         {
1100                 _, err := io.ReadFull(r, (local40)[:])
1101                 chk(err)
1102         }
1103         ((*(*(struct {
1104                 Formname string
1105                 Fields   []Field
1106         }))(obj)).Formname) = string(local40)
1107         var local42 uint16
1108         {
1109                 p := &local42
1110                 *p = read16(r)
1111         }
1112         ((*(*(struct {
1113                 Formname string
1114                 Fields   []Field
1115         }))(obj)).Fields) = make([]Field, local42)
1116         for local43 := range (*(*(struct {
1117                 Formname string
1118                 Fields   []Field
1119         }))(obj)).Fields {
1120                 if err := pcall(func() {
1121                         (((*(*(struct {
1122                                 Formname string
1123                                 Fields   []Field
1124                         }))(obj)).Fields)[local43]).deserialize(r)
1125                 }); err != nil {
1126                         if err == io.EOF {
1127                                 chk(io.EOF)
1128                         }
1129                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
1130                 }
1131         }
1132 }
1133
1134 func (obj *ToSrvReqMedia) serialize(w io.Writer) {
1135         if len(((*(*(struct {
1136                 Filenames []string
1137         }))(obj)).Filenames)) > math.MaxUint16 {
1138                 chk(ErrTooLong)
1139         }
1140         {
1141                 x := uint16(len(((*(*(struct {
1142                         Filenames []string
1143                 }))(obj)).Filenames)))
1144                 write16(w, uint16(x))
1145         }
1146         for local44 := range (*(*(struct {
1147                 Filenames []string
1148         }))(obj)).Filenames {
1149                 if len(([]byte(((*(*(struct {
1150                         Filenames []string
1151                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1152                         chk(ErrTooLong)
1153                 }
1154                 {
1155                         x := uint16(len(([]byte(((*(*(struct {
1156                                 Filenames []string
1157                         }))(obj)).Filenames)[local44]))))
1158                         write16(w, uint16(x))
1159                 }
1160                 {
1161                         _, err := w.Write(([]byte(((*(*(struct {
1162                                 Filenames []string
1163                         }))(obj)).Filenames)[local44]))[:])
1164                         chk(err)
1165                 }
1166         }
1167 }
1168
1169 func (obj *ToSrvReqMedia) deserialize(r io.Reader) {
1170         var local45 uint16
1171         {
1172                 p := &local45
1173                 *p = read16(r)
1174         }
1175         ((*(*(struct {
1176                 Filenames []string
1177         }))(obj)).Filenames) = make([]string, local45)
1178         for local46 := range (*(*(struct {
1179                 Filenames []string
1180         }))(obj)).Filenames {
1181                 var local47 []uint8
1182                 var local48 uint16
1183                 {
1184                         p := &local48
1185                         *p = read16(r)
1186                 }
1187                 (local47) = make([]uint8, local48)
1188                 {
1189                         _, err := io.ReadFull(r, (local47)[:])
1190                         chk(err)
1191                 }
1192                 (((*(*(struct {
1193                         Filenames []string
1194                 }))(obj)).Filenames)[local46]) = string(local47)
1195         }
1196 }
1197
1198 func (obj *ToSrvCltReady) serialize(w io.Writer) {
1199         {
1200                 x := (*(*(struct {
1201                         // Version information.
1202                         Major, Minor, Patch uint8
1203                         Reserved            uint8
1204                         Version             string
1205                         Formspec            uint16
1206                 }))(obj)).Major
1207                 write8(w, uint8(x))
1208         }
1209         {
1210                 x := (*(*(struct {
1211                         // Version information.
1212                         Major, Minor, Patch uint8
1213                         Reserved            uint8
1214                         Version             string
1215                         Formspec            uint16
1216                 }))(obj)).Minor
1217                 write8(w, uint8(x))
1218         }
1219         {
1220                 x := (*(*(struct {
1221                         // Version information.
1222                         Major, Minor, Patch uint8
1223                         Reserved            uint8
1224                         Version             string
1225                         Formspec            uint16
1226                 }))(obj)).Patch
1227                 write8(w, uint8(x))
1228         }
1229         {
1230                 x := (*(*(struct {
1231                         // Version information.
1232                         Major, Minor, Patch uint8
1233                         Reserved            uint8
1234                         Version             string
1235                         Formspec            uint16
1236                 }))(obj)).Reserved
1237                 write8(w, uint8(x))
1238         }
1239         if len(([]byte((*(*(struct {
1240                 // Version information.
1241                 Major, Minor, Patch uint8
1242                 Reserved            uint8
1243                 Version             string
1244                 Formspec            uint16
1245         }))(obj)).Version))) > math.MaxUint16 {
1246                 chk(ErrTooLong)
1247         }
1248         {
1249                 x := uint16(len(([]byte((*(*(struct {
1250                         // Version information.
1251                         Major, Minor, Patch uint8
1252                         Reserved            uint8
1253                         Version             string
1254                         Formspec            uint16
1255                 }))(obj)).Version))))
1256                 write16(w, uint16(x))
1257         }
1258         {
1259                 _, err := w.Write(([]byte((*(*(struct {
1260                         // Version information.
1261                         Major, Minor, Patch uint8
1262                         Reserved            uint8
1263                         Version             string
1264                         Formspec            uint16
1265                 }))(obj)).Version))[:])
1266                 chk(err)
1267         }
1268         {
1269                 x := (*(*(struct {
1270                         // Version information.
1271                         Major, Minor, Patch uint8
1272                         Reserved            uint8
1273                         Version             string
1274                         Formspec            uint16
1275                 }))(obj)).Formspec
1276                 write16(w, uint16(x))
1277         }
1278 }
1279
1280 func (obj *ToSrvCltReady) deserialize(r io.Reader) {
1281         {
1282                 p := &(*(*(struct {
1283                         // Version information.
1284                         Major, Minor, Patch uint8
1285                         Reserved            uint8
1286                         Version             string
1287                         Formspec            uint16
1288                 }))(obj)).Major
1289                 *p = read8(r)
1290         }
1291         {
1292                 p := &(*(*(struct {
1293                         // Version information.
1294                         Major, Minor, Patch uint8
1295                         Reserved            uint8
1296                         Version             string
1297                         Formspec            uint16
1298                 }))(obj)).Minor
1299                 *p = read8(r)
1300         }
1301         {
1302                 p := &(*(*(struct {
1303                         // Version information.
1304                         Major, Minor, Patch uint8
1305                         Reserved            uint8
1306                         Version             string
1307                         Formspec            uint16
1308                 }))(obj)).Patch
1309                 *p = read8(r)
1310         }
1311         {
1312                 p := &(*(*(struct {
1313                         // Version information.
1314                         Major, Minor, Patch uint8
1315                         Reserved            uint8
1316                         Version             string
1317                         Formspec            uint16
1318                 }))(obj)).Reserved
1319                 *p = read8(r)
1320         }
1321         var local49 []uint8
1322         var local50 uint16
1323         {
1324                 p := &local50
1325                 *p = read16(r)
1326         }
1327         (local49) = make([]uint8, local50)
1328         {
1329                 _, err := io.ReadFull(r, (local49)[:])
1330                 chk(err)
1331         }
1332         ((*(*(struct {
1333                 // Version information.
1334                 Major, Minor, Patch uint8
1335                 Reserved            uint8
1336                 Version             string
1337                 Formspec            uint16
1338         }))(obj)).Version) = string(local49)
1339         {
1340                 p := &(*(*(struct {
1341                         // Version information.
1342                         Major, Minor, Patch uint8
1343                         Reserved            uint8
1344                         Version             string
1345                         Formspec            uint16
1346                 }))(obj)).Formspec
1347                 *p = read16(r)
1348         }
1349 }
1350
1351 func (obj *ToSrvFirstSRP) serialize(w io.Writer) {
1352         if len(((*(*(struct {
1353                 Salt        []byte
1354                 Verifier    []byte
1355                 EmptyPasswd bool
1356         }))(obj)).Salt)) > math.MaxUint16 {
1357                 chk(ErrTooLong)
1358         }
1359         {
1360                 x := uint16(len(((*(*(struct {
1361                         Salt        []byte
1362                         Verifier    []byte
1363                         EmptyPasswd bool
1364                 }))(obj)).Salt)))
1365                 write16(w, uint16(x))
1366         }
1367         {
1368                 _, err := w.Write(((*(*(struct {
1369                         Salt        []byte
1370                         Verifier    []byte
1371                         EmptyPasswd bool
1372                 }))(obj)).Salt)[:])
1373                 chk(err)
1374         }
1375         if len(((*(*(struct {
1376                 Salt        []byte
1377                 Verifier    []byte
1378                 EmptyPasswd bool
1379         }))(obj)).Verifier)) > math.MaxUint16 {
1380                 chk(ErrTooLong)
1381         }
1382         {
1383                 x := uint16(len(((*(*(struct {
1384                         Salt        []byte
1385                         Verifier    []byte
1386                         EmptyPasswd bool
1387                 }))(obj)).Verifier)))
1388                 write16(w, uint16(x))
1389         }
1390         {
1391                 _, err := w.Write(((*(*(struct {
1392                         Salt        []byte
1393                         Verifier    []byte
1394                         EmptyPasswd bool
1395                 }))(obj)).Verifier)[:])
1396                 chk(err)
1397         }
1398         {
1399                 x := (*(*(struct {
1400                         Salt        []byte
1401                         Verifier    []byte
1402                         EmptyPasswd bool
1403                 }))(obj)).EmptyPasswd
1404                 if x {
1405                         write8(w, 1)
1406                 } else {
1407                         write8(w, 0)
1408                 }
1409         }
1410 }
1411
1412 func (obj *ToSrvFirstSRP) deserialize(r io.Reader) {
1413         var local51 uint16
1414         {
1415                 p := &local51
1416                 *p = read16(r)
1417         }
1418         ((*(*(struct {
1419                 Salt        []byte
1420                 Verifier    []byte
1421                 EmptyPasswd bool
1422         }))(obj)).Salt) = make([]byte, local51)
1423         {
1424                 _, err := io.ReadFull(r, ((*(*(struct {
1425                         Salt        []byte
1426                         Verifier    []byte
1427                         EmptyPasswd bool
1428                 }))(obj)).Salt)[:])
1429                 chk(err)
1430         }
1431         var local52 uint16
1432         {
1433                 p := &local52
1434                 *p = read16(r)
1435         }
1436         ((*(*(struct {
1437                 Salt        []byte
1438                 Verifier    []byte
1439                 EmptyPasswd bool
1440         }))(obj)).Verifier) = make([]byte, local52)
1441         {
1442                 _, err := io.ReadFull(r, ((*(*(struct {
1443                         Salt        []byte
1444                         Verifier    []byte
1445                         EmptyPasswd bool
1446                 }))(obj)).Verifier)[:])
1447                 chk(err)
1448         }
1449         {
1450                 p := &(*(*(struct {
1451                         Salt        []byte
1452                         Verifier    []byte
1453                         EmptyPasswd bool
1454                 }))(obj)).EmptyPasswd
1455                 switch n := read8(r); n {
1456                 case 0:
1457                         *p = false
1458                 case 1:
1459                         *p = true
1460                 default:
1461                         chk(fmt.Errorf("invalid bool: %d", n))
1462                 }
1463         }
1464 }
1465
1466 func (obj *ToSrvSRPBytesA) serialize(w io.Writer) {
1467         if len(((*(*(struct {
1468                 A      []byte
1469                 NoSHA1 bool
1470         }))(obj)).A)) > math.MaxUint16 {
1471                 chk(ErrTooLong)
1472         }
1473         {
1474                 x := uint16(len(((*(*(struct {
1475                         A      []byte
1476                         NoSHA1 bool
1477                 }))(obj)).A)))
1478                 write16(w, uint16(x))
1479         }
1480         {
1481                 _, err := w.Write(((*(*(struct {
1482                         A      []byte
1483                         NoSHA1 bool
1484                 }))(obj)).A)[:])
1485                 chk(err)
1486         }
1487         {
1488                 x := (*(*(struct {
1489                         A      []byte
1490                         NoSHA1 bool
1491                 }))(obj)).NoSHA1
1492                 if x {
1493                         write8(w, 1)
1494                 } else {
1495                         write8(w, 0)
1496                 }
1497         }
1498 }
1499
1500 func (obj *ToSrvSRPBytesA) deserialize(r io.Reader) {
1501         var local53 uint16
1502         {
1503                 p := &local53
1504                 *p = read16(r)
1505         }
1506         ((*(*(struct {
1507                 A      []byte
1508                 NoSHA1 bool
1509         }))(obj)).A) = make([]byte, local53)
1510         {
1511                 _, err := io.ReadFull(r, ((*(*(struct {
1512                         A      []byte
1513                         NoSHA1 bool
1514                 }))(obj)).A)[:])
1515                 chk(err)
1516         }
1517         {
1518                 p := &(*(*(struct {
1519                         A      []byte
1520                         NoSHA1 bool
1521                 }))(obj)).NoSHA1
1522                 switch n := read8(r); n {
1523                 case 0:
1524                         *p = false
1525                 case 1:
1526                         *p = true
1527                 default:
1528                         chk(fmt.Errorf("invalid bool: %d", n))
1529                 }
1530         }
1531 }
1532
1533 func (obj *ToSrvSRPBytesM) serialize(w io.Writer) {
1534         if len(((*(*(struct {
1535                 M []byte
1536         }))(obj)).M)) > math.MaxUint16 {
1537                 chk(ErrTooLong)
1538         }
1539         {
1540                 x := uint16(len(((*(*(struct {
1541                         M []byte
1542                 }))(obj)).M)))
1543                 write16(w, uint16(x))
1544         }
1545         {
1546                 _, err := w.Write(((*(*(struct {
1547                         M []byte
1548                 }))(obj)).M)[:])
1549                 chk(err)
1550         }
1551 }
1552
1553 func (obj *ToSrvSRPBytesM) deserialize(r io.Reader) {
1554         var local54 uint16
1555         {
1556                 p := &local54
1557                 *p = read16(r)
1558         }
1559         ((*(*(struct {
1560                 M []byte
1561         }))(obj)).M) = make([]byte, local54)
1562         {
1563                 _, err := io.ReadFull(r, ((*(*(struct {
1564                         M []byte
1565                 }))(obj)).M)[:])
1566                 chk(err)
1567         }
1568 }
1569
1570 func (obj *ToCltHello) serialize(w io.Writer) {
1571         {
1572                 x := (*(*(struct {
1573                         SerializeVer uint8
1574                         Compression  CompressionModes
1575                         ProtoVer     uint16
1576                         AuthMethods
1577                         Username string
1578                 }))(obj)).SerializeVer
1579                 write8(w, uint8(x))
1580         }
1581         if err := pcall(func() {
1582                 ((*(*(struct {
1583                         SerializeVer uint8
1584                         Compression  CompressionModes
1585                         ProtoVer     uint16
1586                         AuthMethods
1587                         Username string
1588                 }))(obj)).Compression).serialize(w)
1589         }); err != nil {
1590                 if err == io.EOF {
1591                         chk(io.EOF)
1592                 }
1593                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
1594         }
1595         {
1596                 x := (*(*(struct {
1597                         SerializeVer uint8
1598                         Compression  CompressionModes
1599                         ProtoVer     uint16
1600                         AuthMethods
1601                         Username string
1602                 }))(obj)).ProtoVer
1603                 write16(w, uint16(x))
1604         }
1605         if err := pcall(func() {
1606                 ((*(*(struct {
1607                         SerializeVer uint8
1608                         Compression  CompressionModes
1609                         ProtoVer     uint16
1610                         AuthMethods
1611                         Username string
1612                 }))(obj)).AuthMethods).serialize(w)
1613         }); err != nil {
1614                 if err == io.EOF {
1615                         chk(io.EOF)
1616                 }
1617                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1618         }
1619         if len(([]byte((*(*(struct {
1620                 SerializeVer uint8
1621                 Compression  CompressionModes
1622                 ProtoVer     uint16
1623                 AuthMethods
1624                 Username string
1625         }))(obj)).Username))) > math.MaxUint16 {
1626                 chk(ErrTooLong)
1627         }
1628         {
1629                 x := uint16(len(([]byte((*(*(struct {
1630                         SerializeVer uint8
1631                         Compression  CompressionModes
1632                         ProtoVer     uint16
1633                         AuthMethods
1634                         Username string
1635                 }))(obj)).Username))))
1636                 write16(w, uint16(x))
1637         }
1638         {
1639                 _, err := w.Write(([]byte((*(*(struct {
1640                         SerializeVer uint8
1641                         Compression  CompressionModes
1642                         ProtoVer     uint16
1643                         AuthMethods
1644                         Username string
1645                 }))(obj)).Username))[:])
1646                 chk(err)
1647         }
1648 }
1649
1650 func (obj *ToCltHello) deserialize(r io.Reader) {
1651         {
1652                 p := &(*(*(struct {
1653                         SerializeVer uint8
1654                         Compression  CompressionModes
1655                         ProtoVer     uint16
1656                         AuthMethods
1657                         Username string
1658                 }))(obj)).SerializeVer
1659                 *p = read8(r)
1660         }
1661         if err := pcall(func() {
1662                 ((*(*(struct {
1663                         SerializeVer uint8
1664                         Compression  CompressionModes
1665                         ProtoVer     uint16
1666                         AuthMethods
1667                         Username string
1668                 }))(obj)).Compression).deserialize(r)
1669         }); err != nil {
1670                 if err == io.EOF {
1671                         chk(io.EOF)
1672                 }
1673                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
1674         }
1675         {
1676                 p := &(*(*(struct {
1677                         SerializeVer uint8
1678                         Compression  CompressionModes
1679                         ProtoVer     uint16
1680                         AuthMethods
1681                         Username string
1682                 }))(obj)).ProtoVer
1683                 *p = read16(r)
1684         }
1685         if err := pcall(func() {
1686                 ((*(*(struct {
1687                         SerializeVer uint8
1688                         Compression  CompressionModes
1689                         ProtoVer     uint16
1690                         AuthMethods
1691                         Username string
1692                 }))(obj)).AuthMethods).deserialize(r)
1693         }); err != nil {
1694                 if err == io.EOF {
1695                         chk(io.EOF)
1696                 }
1697                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1698         }
1699         var local55 []uint8
1700         var local56 uint16
1701         {
1702                 p := &local56
1703                 *p = read16(r)
1704         }
1705         (local55) = make([]uint8, local56)
1706         {
1707                 _, err := io.ReadFull(r, (local55)[:])
1708                 chk(err)
1709         }
1710         ((*(*(struct {
1711                 SerializeVer uint8
1712                 Compression  CompressionModes
1713                 ProtoVer     uint16
1714                 AuthMethods
1715                 Username string
1716         }))(obj)).Username) = string(local55)
1717 }
1718
1719 func (obj *ToCltAcceptAuth) serialize(w io.Writer) {
1720         if err := pcall(func() {
1721                 ((*(*(struct {
1722                         // The client does the equivalent of
1723                         //      PlayerPos[1] -= 5
1724                         // before using PlayerPos.
1725                         PlayerPos Pos
1726
1727                         MapSeed         uint64
1728                         SendInterval    float32
1729                         SudoAuthMethods AuthMethods
1730                 }))(obj)).PlayerPos).serialize(w)
1731         }); err != nil {
1732                 if err == io.EOF {
1733                         chk(io.EOF)
1734                 }
1735                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
1736         }
1737         {
1738                 x := (*(*(struct {
1739                         // The client does the equivalent of
1740                         //      PlayerPos[1] -= 5
1741                         // before using PlayerPos.
1742                         PlayerPos Pos
1743
1744                         MapSeed         uint64
1745                         SendInterval    float32
1746                         SudoAuthMethods AuthMethods
1747                 }))(obj)).MapSeed
1748                 write64(w, uint64(x))
1749         }
1750         {
1751                 x := (*(*(struct {
1752                         // The client does the equivalent of
1753                         //      PlayerPos[1] -= 5
1754                         // before using PlayerPos.
1755                         PlayerPos Pos
1756
1757                         MapSeed         uint64
1758                         SendInterval    float32
1759                         SudoAuthMethods AuthMethods
1760                 }))(obj)).SendInterval
1761                 write32(w, math.Float32bits(x))
1762         }
1763         if err := pcall(func() {
1764                 ((*(*(struct {
1765                         // The client does the equivalent of
1766                         //      PlayerPos[1] -= 5
1767                         // before using PlayerPos.
1768                         PlayerPos Pos
1769
1770                         MapSeed         uint64
1771                         SendInterval    float32
1772                         SudoAuthMethods AuthMethods
1773                 }))(obj)).SudoAuthMethods).serialize(w)
1774         }); err != nil {
1775                 if err == io.EOF {
1776                         chk(io.EOF)
1777                 }
1778                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1779         }
1780 }
1781
1782 func (obj *ToCltAcceptAuth) deserialize(r io.Reader) {
1783         if err := pcall(func() {
1784                 ((*(*(struct {
1785                         // The client does the equivalent of
1786                         //      PlayerPos[1] -= 5
1787                         // before using PlayerPos.
1788                         PlayerPos Pos
1789
1790                         MapSeed         uint64
1791                         SendInterval    float32
1792                         SudoAuthMethods AuthMethods
1793                 }))(obj)).PlayerPos).deserialize(r)
1794         }); err != nil {
1795                 if err == io.EOF {
1796                         chk(io.EOF)
1797                 }
1798                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
1799         }
1800         {
1801                 p := &(*(*(struct {
1802                         // The client does the equivalent of
1803                         //      PlayerPos[1] -= 5
1804                         // before using PlayerPos.
1805                         PlayerPos Pos
1806
1807                         MapSeed         uint64
1808                         SendInterval    float32
1809                         SudoAuthMethods AuthMethods
1810                 }))(obj)).MapSeed
1811                 *p = read64(r)
1812         }
1813         {
1814                 p := &(*(*(struct {
1815                         // The client does the equivalent of
1816                         //      PlayerPos[1] -= 5
1817                         // before using PlayerPos.
1818                         PlayerPos Pos
1819
1820                         MapSeed         uint64
1821                         SendInterval    float32
1822                         SudoAuthMethods AuthMethods
1823                 }))(obj)).SendInterval
1824                 *p = math.Float32frombits(read32(r))
1825         }
1826         if err := pcall(func() {
1827                 ((*(*(struct {
1828                         // The client does the equivalent of
1829                         //      PlayerPos[1] -= 5
1830                         // before using PlayerPos.
1831                         PlayerPos Pos
1832
1833                         MapSeed         uint64
1834                         SendInterval    float32
1835                         SudoAuthMethods AuthMethods
1836                 }))(obj)).SudoAuthMethods).deserialize(r)
1837         }); err != nil {
1838                 if err == io.EOF {
1839                         chk(io.EOF)
1840                 }
1841                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1842         }
1843 }
1844
1845 func (obj *ToCltAcceptSudoMode) serialize(w io.Writer) {
1846         if err := pcall(func() {
1847                 ((*(*(struct {
1848                         SudoAuthMethods AuthMethods
1849                 }))(obj)).SudoAuthMethods).serialize(w)
1850         }); err != nil {
1851                 if err == io.EOF {
1852                         chk(io.EOF)
1853                 }
1854                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1855         }
1856         {
1857                 local57 := [15]byte{}
1858                 {
1859                         _, err := w.Write((local57)[:])
1860                         chk(err)
1861                 }
1862         }
1863 }
1864
1865 func (obj *ToCltAcceptSudoMode) deserialize(r io.Reader) {
1866         if err := pcall(func() {
1867                 ((*(*(struct {
1868                         SudoAuthMethods AuthMethods
1869                 }))(obj)).SudoAuthMethods).deserialize(r)
1870         }); err != nil {
1871                 if err == io.EOF {
1872                         chk(io.EOF)
1873                 }
1874                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1875         }
1876         {
1877                 var local58 [15]byte
1878                 local59 := [15]byte{}
1879                 {
1880                         _, err := io.ReadFull(r, (local58)[:])
1881                         chk(err)
1882                 }
1883                 if local58 != local59 {
1884                         chk(fmt.Errorf("const %v: %v", "[15]byte{}", local58))
1885                 }
1886         }
1887 }
1888
1889 func (obj *ToCltDenySudoMode) serialize(w io.Writer) {
1890 }
1891
1892 func (obj *ToCltDenySudoMode) deserialize(r io.Reader) {
1893 }
1894
1895 func (obj *ToCltKick) serialize(w io.Writer) {
1896         if err := pcall(func() {
1897                 ((*(*(struct {
1898                         Reason KickReason
1899
1900                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1901                         Custom string
1902
1903                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1904                         Reconnect bool
1905                 }))(obj)).Reason).serialize(w)
1906         }); err != nil {
1907                 if err == io.EOF {
1908                         chk(io.EOF)
1909                 }
1910                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.KickReason", err))
1911         }
1912         if !((*(*(struct {
1913                 Reason KickReason
1914
1915                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1916                 Custom string
1917
1918                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1919                 Reconnect bool
1920         }))(obj)).Reason < maxKickReason) {
1921                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
1922         }
1923         if dr := (*(*(struct {
1924                 Reason KickReason
1925
1926                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1927                 Custom string
1928
1929                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1930                 Reconnect bool
1931         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1932                 if len(([]byte((*(*(struct {
1933                         Reason KickReason
1934
1935                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1936                         Custom string
1937
1938                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1939                         Reconnect bool
1940                 }))(obj)).Custom))) > math.MaxUint16 {
1941                         chk(ErrTooLong)
1942                 }
1943                 {
1944                         x := uint16(len(([]byte((*(*(struct {
1945                                 Reason KickReason
1946
1947                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1948                                 Custom string
1949
1950                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1951                                 Reconnect bool
1952                         }))(obj)).Custom))))
1953                         write16(w, uint16(x))
1954                 }
1955                 {
1956                         _, err := w.Write(([]byte((*(*(struct {
1957                                 Reason KickReason
1958
1959                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1960                                 Custom string
1961
1962                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1963                                 Reconnect bool
1964                         }))(obj)).Custom))[:])
1965                         chk(err)
1966                 }
1967         }
1968         if dr := (*(*(struct {
1969                 Reason KickReason
1970
1971                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1972                 Custom string
1973
1974                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1975                 Reconnect bool
1976         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1977                 {
1978                         x := (*(*(struct {
1979                                 Reason KickReason
1980
1981                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1982                                 Custom string
1983
1984                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1985                                 Reconnect bool
1986                         }))(obj)).Reconnect
1987                         if x {
1988                                 write8(w, 1)
1989                         } else {
1990                                 write8(w, 0)
1991                         }
1992                 }
1993         }
1994 }
1995
1996 func (obj *ToCltKick) deserialize(r io.Reader) {
1997         if err := pcall(func() {
1998                 ((*(*(struct {
1999                         Reason KickReason
2000
2001                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2002                         Custom string
2003
2004                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2005                         Reconnect bool
2006                 }))(obj)).Reason).deserialize(r)
2007         }); err != nil {
2008                 if err == io.EOF {
2009                         chk(io.EOF)
2010                 }
2011                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.KickReason", err))
2012         }
2013         if !((*(*(struct {
2014                 Reason KickReason
2015
2016                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2017                 Custom string
2018
2019                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2020                 Reconnect bool
2021         }))(obj)).Reason < maxKickReason) {
2022                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
2023         }
2024         if dr := (*(*(struct {
2025                 Reason KickReason
2026
2027                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2028                 Custom string
2029
2030                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2031                 Reconnect bool
2032         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2033                 var local60 []uint8
2034                 var local61 uint16
2035                 {
2036                         p := &local61
2037                         *p = read16(r)
2038                 }
2039                 (local60) = make([]uint8, local61)
2040                 {
2041                         _, err := io.ReadFull(r, (local60)[:])
2042                         chk(err)
2043                 }
2044                 ((*(*(struct {
2045                         Reason KickReason
2046
2047                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2048                         Custom string
2049
2050                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2051                         Reconnect bool
2052                 }))(obj)).Custom) = string(local60)
2053         }
2054         if dr := (*(*(struct {
2055                 Reason KickReason
2056
2057                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2058                 Custom string
2059
2060                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2061                 Reconnect bool
2062         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2063                 {
2064                         p := &(*(*(struct {
2065                                 Reason KickReason
2066
2067                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2068                                 Custom string
2069
2070                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2071                                 Reconnect bool
2072                         }))(obj)).Reconnect
2073                         switch n := read8(r); n {
2074                         case 0:
2075                                 *p = false
2076                         case 1:
2077                                 *p = true
2078                         default:
2079                                 chk(fmt.Errorf("invalid bool: %d", n))
2080                         }
2081                 }
2082         }
2083 }
2084
2085 func (obj *ToCltBlkData) serialize(w io.Writer) {
2086         for local62 := range (*(*(struct {
2087                 Blkpos [3]int16
2088                 Blk    MapBlk
2089         }))(obj)).Blkpos {
2090                 {
2091                         x := ((*(*(struct {
2092                                 Blkpos [3]int16
2093                                 Blk    MapBlk
2094                         }))(obj)).Blkpos)[local62]
2095                         write16(w, uint16(x))
2096                 }
2097         }
2098         if err := pcall(func() {
2099                 ((*(*(struct {
2100                         Blkpos [3]int16
2101                         Blk    MapBlk
2102                 }))(obj)).Blk).serialize(w)
2103         }); err != nil {
2104                 if err == io.EOF {
2105                         chk(io.EOF)
2106                 }
2107                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlk", err))
2108         }
2109 }
2110
2111 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2112         for local63 := range (*(*(struct {
2113                 Blkpos [3]int16
2114                 Blk    MapBlk
2115         }))(obj)).Blkpos {
2116                 {
2117                         p := &((*(*(struct {
2118                                 Blkpos [3]int16
2119                                 Blk    MapBlk
2120                         }))(obj)).Blkpos)[local63]
2121                         *p = int16(read16(r))
2122                 }
2123         }
2124         if err := pcall(func() {
2125                 ((*(*(struct {
2126                         Blkpos [3]int16
2127                         Blk    MapBlk
2128                 }))(obj)).Blk).deserialize(r)
2129         }); err != nil {
2130                 if err == io.EOF {
2131                         chk(io.EOF)
2132                 }
2133                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlk", err))
2134         }
2135 }
2136
2137 func (obj *ToCltAddNode) serialize(w io.Writer) {
2138         for local64 := range (*(*(struct {
2139                 Pos [3]int16
2140                 Node
2141                 KeepMeta bool
2142         }))(obj)).Pos {
2143                 {
2144                         x := ((*(*(struct {
2145                                 Pos [3]int16
2146                                 Node
2147                                 KeepMeta bool
2148                         }))(obj)).Pos)[local64]
2149                         write16(w, uint16(x))
2150                 }
2151         }
2152         if err := pcall(func() {
2153                 ((*(*(struct {
2154                         Pos [3]int16
2155                         Node
2156                         KeepMeta bool
2157                 }))(obj)).Node).serialize(w)
2158         }); err != nil {
2159                 if err == io.EOF {
2160                         chk(io.EOF)
2161                 }
2162                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Node", err))
2163         }
2164         {
2165                 x := (*(*(struct {
2166                         Pos [3]int16
2167                         Node
2168                         KeepMeta bool
2169                 }))(obj)).KeepMeta
2170                 if x {
2171                         write8(w, 1)
2172                 } else {
2173                         write8(w, 0)
2174                 }
2175         }
2176 }
2177
2178 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2179         for local65 := range (*(*(struct {
2180                 Pos [3]int16
2181                 Node
2182                 KeepMeta bool
2183         }))(obj)).Pos {
2184                 {
2185                         p := &((*(*(struct {
2186                                 Pos [3]int16
2187                                 Node
2188                                 KeepMeta bool
2189                         }))(obj)).Pos)[local65]
2190                         *p = int16(read16(r))
2191                 }
2192         }
2193         if err := pcall(func() {
2194                 ((*(*(struct {
2195                         Pos [3]int16
2196                         Node
2197                         KeepMeta bool
2198                 }))(obj)).Node).deserialize(r)
2199         }); err != nil {
2200                 if err == io.EOF {
2201                         chk(io.EOF)
2202                 }
2203                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Node", err))
2204         }
2205         {
2206                 p := &(*(*(struct {
2207                         Pos [3]int16
2208                         Node
2209                         KeepMeta bool
2210                 }))(obj)).KeepMeta
2211                 switch n := read8(r); n {
2212                 case 0:
2213                         *p = false
2214                 case 1:
2215                         *p = true
2216                 default:
2217                         chk(fmt.Errorf("invalid bool: %d", n))
2218                 }
2219         }
2220 }
2221
2222 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2223         for local66 := range (*(*(struct {
2224                 Pos [3]int16
2225         }))(obj)).Pos {
2226                 {
2227                         x := ((*(*(struct {
2228                                 Pos [3]int16
2229                         }))(obj)).Pos)[local66]
2230                         write16(w, uint16(x))
2231                 }
2232         }
2233 }
2234
2235 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2236         for local67 := range (*(*(struct {
2237                 Pos [3]int16
2238         }))(obj)).Pos {
2239                 {
2240                         p := &((*(*(struct {
2241                                 Pos [3]int16
2242                         }))(obj)).Pos)[local67]
2243                         *p = int16(read16(r))
2244                 }
2245         }
2246 }
2247
2248 func (obj *ToCltInv) serialize(w io.Writer) {
2249         {
2250                 _, err := w.Write(([]byte((*(*(struct {
2251                         //mt:raw
2252                         Inv string
2253                 }))(obj)).Inv))[:])
2254                 chk(err)
2255         }
2256 }
2257
2258 func (obj *ToCltInv) deserialize(r io.Reader) {
2259         var local68 []uint8
2260         {
2261                 var err error
2262                 (local68), err = io.ReadAll(r)
2263                 chk(err)
2264         }
2265         ((*(*(struct {
2266                 //mt:raw
2267                 Inv string
2268         }))(obj)).Inv) = string(local68)
2269 }
2270
2271 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2272         {
2273                 x := (*(*(struct {
2274                         Time  uint16  // %24000
2275                         Speed float32 // Speed times faster than real time
2276                 }))(obj)).Time
2277                 write16(w, uint16(x))
2278         }
2279         {
2280                 x := (*(*(struct {
2281                         Time  uint16  // %24000
2282                         Speed float32 // Speed times faster than real time
2283                 }))(obj)).Speed
2284                 write32(w, math.Float32bits(x))
2285         }
2286 }
2287
2288 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2289         {
2290                 p := &(*(*(struct {
2291                         Time  uint16  // %24000
2292                         Speed float32 // Speed times faster than real time
2293                 }))(obj)).Time
2294                 *p = read16(r)
2295         }
2296         {
2297                 p := &(*(*(struct {
2298                         Time  uint16  // %24000
2299                         Speed float32 // Speed times faster than real time
2300                 }))(obj)).Speed
2301                 *p = math.Float32frombits(read32(r))
2302         }
2303 }
2304
2305 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
2306         if err := pcall(func() {
2307                 ((*(*(struct {
2308                         Flags CSMRestrictionFlags
2309
2310                         // MapRange is the maximum distance from the player CSMs can read the map
2311                         // if Flags&LimitMapRange != 0.
2312                         MapRange uint32
2313                 }))(obj)).Flags).serialize(w)
2314         }); err != nil {
2315                 if err == io.EOF {
2316                         chk(io.EOF)
2317                 }
2318                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CSMRestrictionFlags", err))
2319         }
2320         {
2321                 x := (*(*(struct {
2322                         Flags CSMRestrictionFlags
2323
2324                         // MapRange is the maximum distance from the player CSMs can read the map
2325                         // if Flags&LimitMapRange != 0.
2326                         MapRange uint32
2327                 }))(obj)).MapRange
2328                 write32(w, uint32(x))
2329         }
2330 }
2331
2332 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2333         if err := pcall(func() {
2334                 ((*(*(struct {
2335                         Flags CSMRestrictionFlags
2336
2337                         // MapRange is the maximum distance from the player CSMs can read the map
2338                         // if Flags&LimitMapRange != 0.
2339                         MapRange uint32
2340                 }))(obj)).Flags).deserialize(r)
2341         }); err != nil {
2342                 if err == io.EOF {
2343                         chk(io.EOF)
2344                 }
2345                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CSMRestrictionFlags", err))
2346         }
2347         {
2348                 p := &(*(*(struct {
2349                         Flags CSMRestrictionFlags
2350
2351                         // MapRange is the maximum distance from the player CSMs can read the map
2352                         // if Flags&LimitMapRange != 0.
2353                         MapRange uint32
2354                 }))(obj)).MapRange
2355                 *p = read32(r)
2356         }
2357 }
2358
2359 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2360         if err := pcall(func() {
2361                 ((*(*(struct {
2362                         Vel Vec
2363                 }))(obj)).Vel).serialize(w)
2364         }); err != nil {
2365                 if err == io.EOF {
2366                         chk(io.EOF)
2367                 }
2368                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
2369         }
2370 }
2371
2372 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2373         if err := pcall(func() {
2374                 ((*(*(struct {
2375                         Vel Vec
2376                 }))(obj)).Vel).deserialize(r)
2377         }); err != nil {
2378                 if err == io.EOF {
2379                         chk(io.EOF)
2380                 }
2381                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
2382         }
2383 }
2384
2385 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2386         if len(([]byte((*(*(struct {
2387                 RawHash       string
2388                 Filename      string
2389                 CallbackToken uint32
2390                 ShouldCache   bool
2391         }))(obj)).RawHash))) > math.MaxUint16 {
2392                 chk(ErrTooLong)
2393         }
2394         {
2395                 x := uint16(len(([]byte((*(*(struct {
2396                         RawHash       string
2397                         Filename      string
2398                         CallbackToken uint32
2399                         ShouldCache   bool
2400                 }))(obj)).RawHash))))
2401                 write16(w, uint16(x))
2402         }
2403         {
2404                 _, err := w.Write(([]byte((*(*(struct {
2405                         RawHash       string
2406                         Filename      string
2407                         CallbackToken uint32
2408                         ShouldCache   bool
2409                 }))(obj)).RawHash))[:])
2410                 chk(err)
2411         }
2412         if len(([]byte((*(*(struct {
2413                 RawHash       string
2414                 Filename      string
2415                 CallbackToken uint32
2416                 ShouldCache   bool
2417         }))(obj)).Filename))) > math.MaxUint16 {
2418                 chk(ErrTooLong)
2419         }
2420         {
2421                 x := uint16(len(([]byte((*(*(struct {
2422                         RawHash       string
2423                         Filename      string
2424                         CallbackToken uint32
2425                         ShouldCache   bool
2426                 }))(obj)).Filename))))
2427                 write16(w, uint16(x))
2428         }
2429         {
2430                 _, err := w.Write(([]byte((*(*(struct {
2431                         RawHash       string
2432                         Filename      string
2433                         CallbackToken uint32
2434                         ShouldCache   bool
2435                 }))(obj)).Filename))[:])
2436                 chk(err)
2437         }
2438         {
2439                 x := (*(*(struct {
2440                         RawHash       string
2441                         Filename      string
2442                         CallbackToken uint32
2443                         ShouldCache   bool
2444                 }))(obj)).CallbackToken
2445                 write32(w, uint32(x))
2446         }
2447         {
2448                 x := (*(*(struct {
2449                         RawHash       string
2450                         Filename      string
2451                         CallbackToken uint32
2452                         ShouldCache   bool
2453                 }))(obj)).ShouldCache
2454                 if x {
2455                         write8(w, 1)
2456                 } else {
2457                         write8(w, 0)
2458                 }
2459         }
2460 }
2461
2462 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2463         var local69 []uint8
2464         var local70 uint16
2465         {
2466                 p := &local70
2467                 *p = read16(r)
2468         }
2469         (local69) = make([]uint8, local70)
2470         {
2471                 _, err := io.ReadFull(r, (local69)[:])
2472                 chk(err)
2473         }
2474         ((*(*(struct {
2475                 RawHash       string
2476                 Filename      string
2477                 CallbackToken uint32
2478                 ShouldCache   bool
2479         }))(obj)).RawHash) = string(local69)
2480         var local71 []uint8
2481         var local72 uint16
2482         {
2483                 p := &local72
2484                 *p = read16(r)
2485         }
2486         (local71) = make([]uint8, local72)
2487         {
2488                 _, err := io.ReadFull(r, (local71)[:])
2489                 chk(err)
2490         }
2491         ((*(*(struct {
2492                 RawHash       string
2493                 Filename      string
2494                 CallbackToken uint32
2495                 ShouldCache   bool
2496         }))(obj)).Filename) = string(local71)
2497         {
2498                 p := &(*(*(struct {
2499                         RawHash       string
2500                         Filename      string
2501                         CallbackToken uint32
2502                         ShouldCache   bool
2503                 }))(obj)).CallbackToken
2504                 *p = read32(r)
2505         }
2506         {
2507                 p := &(*(*(struct {
2508                         RawHash       string
2509                         Filename      string
2510                         CallbackToken uint32
2511                         ShouldCache   bool
2512                 }))(obj)).ShouldCache
2513                 switch n := read8(r); n {
2514                 case 0:
2515                         *p = false
2516                 case 1:
2517                         *p = true
2518                 default:
2519                         chk(fmt.Errorf("invalid bool: %d", n))
2520                 }
2521         }
2522 }
2523
2524 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2525         {
2526                 local73 := uint8(1)
2527                 {
2528                         x := local73
2529                         write8(w, uint8(x))
2530                 }
2531         }
2532         if err := pcall(func() {
2533                 ((*(*(struct {
2534                         Type ChatMsgType
2535
2536                         //mt:utf16
2537                         Sender, Text string
2538
2539                         Timestamp int64 // Unix time.
2540                 }))(obj)).Type).serialize(w)
2541         }); err != nil {
2542                 if err == io.EOF {
2543                         chk(io.EOF)
2544                 }
2545                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ChatMsgType", err))
2546         }
2547         local74 := utf16.Encode([]rune((*(*(struct {
2548                 Type ChatMsgType
2549
2550                 //mt:utf16
2551                 Sender, Text string
2552
2553                 Timestamp int64 // Unix time.
2554         }))(obj)).Sender))
2555         if len((local74)) > math.MaxUint16 {
2556                 chk(ErrTooLong)
2557         }
2558         {
2559                 x := uint16(len((local74)))
2560                 write16(w, uint16(x))
2561         }
2562         for local75 := range local74 {
2563                 {
2564                         x := (local74)[local75]
2565                         write16(w, uint16(x))
2566                 }
2567         }
2568         local76 := utf16.Encode([]rune((*(*(struct {
2569                 Type ChatMsgType
2570
2571                 //mt:utf16
2572                 Sender, Text string
2573
2574                 Timestamp int64 // Unix time.
2575         }))(obj)).Text))
2576         if len((local76)) > math.MaxUint16 {
2577                 chk(ErrTooLong)
2578         }
2579         {
2580                 x := uint16(len((local76)))
2581                 write16(w, uint16(x))
2582         }
2583         for local77 := range local76 {
2584                 {
2585                         x := (local76)[local77]
2586                         write16(w, uint16(x))
2587                 }
2588         }
2589         {
2590                 x := (*(*(struct {
2591                         Type ChatMsgType
2592
2593                         //mt:utf16
2594                         Sender, Text string
2595
2596                         Timestamp int64 // Unix time.
2597                 }))(obj)).Timestamp
2598                 write64(w, uint64(x))
2599         }
2600 }
2601
2602 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2603         {
2604                 var local78 uint8
2605                 local79 := uint8(1)
2606                 {
2607                         p := &local78
2608                         *p = read8(r)
2609                 }
2610                 if local78 != local79 {
2611                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local78))
2612                 }
2613         }
2614         if err := pcall(func() {
2615                 ((*(*(struct {
2616                         Type ChatMsgType
2617
2618                         //mt:utf16
2619                         Sender, Text string
2620
2621                         Timestamp int64 // Unix time.
2622                 }))(obj)).Type).deserialize(r)
2623         }); err != nil {
2624                 if err == io.EOF {
2625                         chk(io.EOF)
2626                 }
2627                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ChatMsgType", err))
2628         }
2629         var local80 []uint16
2630         var local81 uint16
2631         {
2632                 p := &local81
2633                 *p = read16(r)
2634         }
2635         (local80) = make([]uint16, local81)
2636         for local82 := range local80 {
2637                 {
2638                         p := &(local80)[local82]
2639                         *p = read16(r)
2640                 }
2641         }
2642         (*(*(struct {
2643                 Type ChatMsgType
2644
2645                 //mt:utf16
2646                 Sender, Text string
2647
2648                 Timestamp int64 // Unix time.
2649         }))(obj)).Sender = string(utf16.Decode(local80))
2650         var local83 []uint16
2651         var local84 uint16
2652         {
2653                 p := &local84
2654                 *p = read16(r)
2655         }
2656         (local83) = make([]uint16, local84)
2657         for local85 := range local83 {
2658                 {
2659                         p := &(local83)[local85]
2660                         *p = read16(r)
2661                 }
2662         }
2663         (*(*(struct {
2664                 Type ChatMsgType
2665
2666                 //mt:utf16
2667                 Sender, Text string
2668
2669                 Timestamp int64 // Unix time.
2670         }))(obj)).Text = string(utf16.Decode(local83))
2671         {
2672                 p := &(*(*(struct {
2673                         Type ChatMsgType
2674
2675                         //mt:utf16
2676                         Sender, Text string
2677
2678                         Timestamp int64 // Unix time.
2679                 }))(obj)).Timestamp
2680                 *p = int64(read64(r))
2681         }
2682 }
2683
2684 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2685         if len(((*(*(struct {
2686                 Remove []AOID
2687                 Add    []AOAdd
2688         }))(obj)).Remove)) > math.MaxUint16 {
2689                 chk(ErrTooLong)
2690         }
2691         {
2692                 x := uint16(len(((*(*(struct {
2693                         Remove []AOID
2694                         Add    []AOAdd
2695                 }))(obj)).Remove)))
2696                 write16(w, uint16(x))
2697         }
2698         for local86 := range (*(*(struct {
2699                 Remove []AOID
2700                 Add    []AOAdd
2701         }))(obj)).Remove {
2702                 if err := pcall(func() {
2703                         (((*(*(struct {
2704                                 Remove []AOID
2705                                 Add    []AOAdd
2706                         }))(obj)).Remove)[local86]).serialize(w)
2707                 }); err != nil {
2708                         if err == io.EOF {
2709                                 chk(io.EOF)
2710                         }
2711                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
2712                 }
2713         }
2714         if len(((*(*(struct {
2715                 Remove []AOID
2716                 Add    []AOAdd
2717         }))(obj)).Add)) > math.MaxUint16 {
2718                 chk(ErrTooLong)
2719         }
2720         {
2721                 x := uint16(len(((*(*(struct {
2722                         Remove []AOID
2723                         Add    []AOAdd
2724                 }))(obj)).Add)))
2725                 write16(w, uint16(x))
2726         }
2727         for local87 := range (*(*(struct {
2728                 Remove []AOID
2729                 Add    []AOAdd
2730         }))(obj)).Add {
2731                 if err := pcall(func() {
2732                         (((*(*(struct {
2733                                 Remove []AOID
2734                                 Add    []AOAdd
2735                         }))(obj)).Add)[local87]).serialize(w)
2736                 }); err != nil {
2737                         if err == io.EOF {
2738                                 chk(io.EOF)
2739                         }
2740                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAdd", err))
2741                 }
2742         }
2743 }
2744
2745 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2746         var local88 uint16
2747         {
2748                 p := &local88
2749                 *p = read16(r)
2750         }
2751         ((*(*(struct {
2752                 Remove []AOID
2753                 Add    []AOAdd
2754         }))(obj)).Remove) = make([]AOID, local88)
2755         for local89 := range (*(*(struct {
2756                 Remove []AOID
2757                 Add    []AOAdd
2758         }))(obj)).Remove {
2759                 if err := pcall(func() {
2760                         (((*(*(struct {
2761                                 Remove []AOID
2762                                 Add    []AOAdd
2763                         }))(obj)).Remove)[local89]).deserialize(r)
2764                 }); err != nil {
2765                         if err == io.EOF {
2766                                 chk(io.EOF)
2767                         }
2768                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
2769                 }
2770         }
2771         var local90 uint16
2772         {
2773                 p := &local90
2774                 *p = read16(r)
2775         }
2776         ((*(*(struct {
2777                 Remove []AOID
2778                 Add    []AOAdd
2779         }))(obj)).Add) = make([]AOAdd, local90)
2780         for local91 := range (*(*(struct {
2781                 Remove []AOID
2782                 Add    []AOAdd
2783         }))(obj)).Add {
2784                 if err := pcall(func() {
2785                         (((*(*(struct {
2786                                 Remove []AOID
2787                                 Add    []AOAdd
2788                         }))(obj)).Add)[local91]).deserialize(r)
2789                 }); err != nil {
2790                         if err == io.EOF {
2791                                 chk(io.EOF)
2792                         }
2793                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAdd", err))
2794                 }
2795         }
2796 }
2797
2798 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
2799         for local92 := range (*(*(struct {
2800                 //mt:raw
2801                 Msgs []IDAOMsg
2802         }))(obj)).Msgs {
2803                 if err := pcall(func() {
2804                         (((*(*(struct {
2805                                 //mt:raw
2806                                 Msgs []IDAOMsg
2807                         }))(obj)).Msgs)[local92]).serialize(w)
2808                 }); err != nil {
2809                         if err == io.EOF {
2810                                 chk(io.EOF)
2811                         }
2812                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.IDAOMsg", err))
2813                 }
2814         }
2815 }
2816
2817 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
2818         for {
2819                 var local93 IDAOMsg
2820                 err := pcall(func() {
2821                         if err := pcall(func() {
2822                                 (local93).deserialize(r)
2823                         }); err != nil {
2824                                 if err == io.EOF {
2825                                         chk(io.EOF)
2826                                 }
2827                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.IDAOMsg", err))
2828                         }
2829                 })
2830                 if err == io.EOF {
2831                         break
2832                 }
2833                 ((*(*(struct {
2834                         //mt:raw
2835                         Msgs []IDAOMsg
2836                 }))(obj)).Msgs) = append(((*(*(struct {
2837                         //mt:raw
2838                         Msgs []IDAOMsg
2839                 }))(obj)).Msgs), local93)
2840                 chk(err)
2841         }
2842 }
2843
2844 func (obj *ToCltHP) serialize(w io.Writer) {
2845         {
2846                 x := (*(*(struct {
2847                         HP uint16
2848                 }))(obj)).HP
2849                 write16(w, uint16(x))
2850         }
2851 }
2852
2853 func (obj *ToCltHP) deserialize(r io.Reader) {
2854         {
2855                 p := &(*(*(struct {
2856                         HP uint16
2857                 }))(obj)).HP
2858                 *p = read16(r)
2859         }
2860 }
2861
2862 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
2863         if err := pcall(func() {
2864                 ((*(*(struct {
2865                         Pos
2866                         Pitch, Yaw float32
2867                 }))(obj)).Pos).serialize(w)
2868         }); err != nil {
2869                 if err == io.EOF {
2870                         chk(io.EOF)
2871                 }
2872                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2873         }
2874         {
2875                 x := (*(*(struct {
2876                         Pos
2877                         Pitch, Yaw float32
2878                 }))(obj)).Pitch
2879                 write32(w, math.Float32bits(x))
2880         }
2881         {
2882                 x := (*(*(struct {
2883                         Pos
2884                         Pitch, Yaw float32
2885                 }))(obj)).Yaw
2886                 write32(w, math.Float32bits(x))
2887         }
2888 }
2889
2890 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
2891         if err := pcall(func() {
2892                 ((*(*(struct {
2893                         Pos
2894                         Pitch, Yaw float32
2895                 }))(obj)).Pos).deserialize(r)
2896         }); err != nil {
2897                 if err == io.EOF {
2898                         chk(io.EOF)
2899                 }
2900                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2901         }
2902         {
2903                 p := &(*(*(struct {
2904                         Pos
2905                         Pitch, Yaw float32
2906                 }))(obj)).Pitch
2907                 *p = math.Float32frombits(read32(r))
2908         }
2909         {
2910                 p := &(*(*(struct {
2911                         Pos
2912                         Pitch, Yaw float32
2913                 }))(obj)).Yaw
2914                 *p = math.Float32frombits(read32(r))
2915         }
2916 }
2917
2918 func (obj *ToCltLegacyKick) serialize(w io.Writer) {
2919         local94 := utf16.Encode([]rune((*(*(struct {
2920                 //mt:utf16
2921                 Reason string
2922         }))(obj)).Reason))
2923         if len((local94)) > math.MaxUint16 {
2924                 chk(ErrTooLong)
2925         }
2926         {
2927                 x := uint16(len((local94)))
2928                 write16(w, uint16(x))
2929         }
2930         for local95 := range local94 {
2931                 {
2932                         x := (local94)[local95]
2933                         write16(w, uint16(x))
2934                 }
2935         }
2936 }
2937
2938 func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
2939         var local96 []uint16
2940         var local97 uint16
2941         {
2942                 p := &local97
2943                 *p = read16(r)
2944         }
2945         (local96) = make([]uint16, local97)
2946         for local98 := range local96 {
2947                 {
2948                         p := &(local96)[local98]
2949                         *p = read16(r)
2950                 }
2951         }
2952         (*(*(struct {
2953                 //mt:utf16
2954                 Reason string
2955         }))(obj)).Reason = string(utf16.Decode(local96))
2956 }
2957
2958 func (obj *ToCltFOV) serialize(w io.Writer) {
2959         {
2960                 x := (*(*(struct {
2961                         FOV            float32
2962                         Multiplier     bool
2963                         TransitionTime float32
2964                 }))(obj)).FOV
2965                 write32(w, math.Float32bits(x))
2966         }
2967         {
2968                 x := (*(*(struct {
2969                         FOV            float32
2970                         Multiplier     bool
2971                         TransitionTime float32
2972                 }))(obj)).Multiplier
2973                 if x {
2974                         write8(w, 1)
2975                 } else {
2976                         write8(w, 0)
2977                 }
2978         }
2979         {
2980                 x := (*(*(struct {
2981                         FOV            float32
2982                         Multiplier     bool
2983                         TransitionTime float32
2984                 }))(obj)).TransitionTime
2985                 write32(w, math.Float32bits(x))
2986         }
2987 }
2988
2989 func (obj *ToCltFOV) deserialize(r io.Reader) {
2990         {
2991                 p := &(*(*(struct {
2992                         FOV            float32
2993                         Multiplier     bool
2994                         TransitionTime float32
2995                 }))(obj)).FOV
2996                 *p = math.Float32frombits(read32(r))
2997         }
2998         {
2999                 p := &(*(*(struct {
3000                         FOV            float32
3001                         Multiplier     bool
3002                         TransitionTime float32
3003                 }))(obj)).Multiplier
3004                 switch n := read8(r); n {
3005                 case 0:
3006                         *p = false
3007                 case 1:
3008                         *p = true
3009                 default:
3010                         chk(fmt.Errorf("invalid bool: %d", n))
3011                 }
3012         }
3013         {
3014                 p := &(*(*(struct {
3015                         FOV            float32
3016                         Multiplier     bool
3017                         TransitionTime float32
3018                 }))(obj)).TransitionTime
3019                 *p = math.Float32frombits(read32(r))
3020         }
3021 }
3022
3023 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3024         {
3025                 x := (*(*(struct {
3026                         PointCam bool
3027                         PointAt  Pos
3028                 }))(obj)).PointCam
3029                 if x {
3030                         write8(w, 1)
3031                 } else {
3032                         write8(w, 0)
3033                 }
3034         }
3035         if err := pcall(func() {
3036                 ((*(*(struct {
3037                         PointCam bool
3038                         PointAt  Pos
3039                 }))(obj)).PointAt).serialize(w)
3040         }); err != nil {
3041                 if err == io.EOF {
3042                         chk(io.EOF)
3043                 }
3044                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3045         }
3046 }
3047
3048 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3049         {
3050                 p := &(*(*(struct {
3051                         PointCam bool
3052                         PointAt  Pos
3053                 }))(obj)).PointCam
3054                 switch n := read8(r); n {
3055                 case 0:
3056                         *p = false
3057                 case 1:
3058                         *p = true
3059                 default:
3060                         chk(fmt.Errorf("invalid bool: %d", n))
3061                 }
3062         }
3063         if err := pcall(func() {
3064                 ((*(*(struct {
3065                         PointCam bool
3066                         PointAt  Pos
3067                 }))(obj)).PointAt).deserialize(r)
3068         }); err != nil {
3069                 if err == io.EOF {
3070                         chk(io.EOF)
3071                 }
3072                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3073         }
3074 }
3075
3076 func (obj *ToCltMedia) serialize(w io.Writer) {
3077         {
3078                 x := (*(*(struct {
3079                         // N is the total number of ToCltMedia packets.
3080                         // I is the index of this packet.
3081                         N, I uint16
3082
3083                         //mt:len32
3084                         Files []struct {
3085                                 Name string
3086
3087                                 //mt:len32
3088                                 Data []byte
3089                         }
3090                 }))(obj)).N
3091                 write16(w, uint16(x))
3092         }
3093         {
3094                 x := (*(*(struct {
3095                         // N is the total number of ToCltMedia packets.
3096                         // I is the index of this packet.
3097                         N, I uint16
3098
3099                         //mt:len32
3100                         Files []struct {
3101                                 Name string
3102
3103                                 //mt:len32
3104                                 Data []byte
3105                         }
3106                 }))(obj)).I
3107                 write16(w, uint16(x))
3108         }
3109         if len(((*(*(struct {
3110                 // N is the total number of ToCltMedia packets.
3111                 // I is the index of this packet.
3112                 N, I uint16
3113
3114                 //mt:len32
3115                 Files []struct {
3116                         Name string
3117
3118                         //mt:len32
3119                         Data []byte
3120                 }
3121         }))(obj)).Files)) > math.MaxUint32 {
3122                 chk(ErrTooLong)
3123         }
3124         {
3125                 x := uint32(len(((*(*(struct {
3126                         // N is the total number of ToCltMedia packets.
3127                         // I is the index of this packet.
3128                         N, I uint16
3129
3130                         //mt:len32
3131                         Files []struct {
3132                                 Name string
3133
3134                                 //mt:len32
3135                                 Data []byte
3136                         }
3137                 }))(obj)).Files)))
3138                 write32(w, uint32(x))
3139         }
3140         for local99 := range (*(*(struct {
3141                 // N is the total number of ToCltMedia packets.
3142                 // I is the index of this packet.
3143                 N, I uint16
3144
3145                 //mt:len32
3146                 Files []struct {
3147                         Name string
3148
3149                         //mt:len32
3150                         Data []byte
3151                 }
3152         }))(obj)).Files {
3153                 if len(([]byte((((*(*(struct {
3154                         // N is the total number of ToCltMedia packets.
3155                         // I is the index of this packet.
3156                         N, I uint16
3157
3158                         //mt:len32
3159                         Files []struct {
3160                                 Name string
3161
3162                                 //mt:len32
3163                                 Data []byte
3164                         }
3165                 }))(obj)).Files)[local99]).Name))) > math.MaxUint16 {
3166                         chk(ErrTooLong)
3167                 }
3168                 {
3169                         x := uint16(len(([]byte((((*(*(struct {
3170                                 // N is the total number of ToCltMedia packets.
3171                                 // I is the index of this packet.
3172                                 N, I uint16
3173
3174                                 //mt:len32
3175                                 Files []struct {
3176                                         Name string
3177
3178                                         //mt:len32
3179                                         Data []byte
3180                                 }
3181                         }))(obj)).Files)[local99]).Name))))
3182                         write16(w, uint16(x))
3183                 }
3184                 {
3185                         _, err := w.Write(([]byte((((*(*(struct {
3186                                 // N is the total number of ToCltMedia packets.
3187                                 // I is the index of this packet.
3188                                 N, I uint16
3189
3190                                 //mt:len32
3191                                 Files []struct {
3192                                         Name string
3193
3194                                         //mt:len32
3195                                         Data []byte
3196                                 }
3197                         }))(obj)).Files)[local99]).Name))[:])
3198                         chk(err)
3199                 }
3200                 if len(((((*(*(struct {
3201                         // N is the total number of ToCltMedia packets.
3202                         // I is the index of this packet.
3203                         N, I uint16
3204
3205                         //mt:len32
3206                         Files []struct {
3207                                 Name string
3208
3209                                 //mt:len32
3210                                 Data []byte
3211                         }
3212                 }))(obj)).Files)[local99]).Data)) > math.MaxUint32 {
3213                         chk(ErrTooLong)
3214                 }
3215                 {
3216                         x := uint32(len(((((*(*(struct {
3217                                 // N is the total number of ToCltMedia packets.
3218                                 // I is the index of this packet.
3219                                 N, I uint16
3220
3221                                 //mt:len32
3222                                 Files []struct {
3223                                         Name string
3224
3225                                         //mt:len32
3226                                         Data []byte
3227                                 }
3228                         }))(obj)).Files)[local99]).Data)))
3229                         write32(w, uint32(x))
3230                 }
3231                 {
3232                         _, err := w.Write(((((*(*(struct {
3233                                 // N is the total number of ToCltMedia packets.
3234                                 // I is the index of this packet.
3235                                 N, I uint16
3236
3237                                 //mt:len32
3238                                 Files []struct {
3239                                         Name string
3240
3241                                         //mt:len32
3242                                         Data []byte
3243                                 }
3244                         }))(obj)).Files)[local99]).Data)[:])
3245                         chk(err)
3246                 }
3247         }
3248 }
3249
3250 func (obj *ToCltMedia) deserialize(r io.Reader) {
3251         {
3252                 p := &(*(*(struct {
3253                         // N is the total number of ToCltMedia packets.
3254                         // I is the index of this packet.
3255                         N, I uint16
3256
3257                         //mt:len32
3258                         Files []struct {
3259                                 Name string
3260
3261                                 //mt:len32
3262                                 Data []byte
3263                         }
3264                 }))(obj)).N
3265                 *p = read16(r)
3266         }
3267         {
3268                 p := &(*(*(struct {
3269                         // N is the total number of ToCltMedia packets.
3270                         // I is the index of this packet.
3271                         N, I uint16
3272
3273                         //mt:len32
3274                         Files []struct {
3275                                 Name string
3276
3277                                 //mt:len32
3278                                 Data []byte
3279                         }
3280                 }))(obj)).I
3281                 *p = read16(r)
3282         }
3283         var local100 uint32
3284         {
3285                 p := &local100
3286                 *p = read32(r)
3287         }
3288         ((*(*(struct {
3289                 // N is the total number of ToCltMedia packets.
3290                 // I is the index of this packet.
3291                 N, I uint16
3292
3293                 //mt:len32
3294                 Files []struct {
3295                         Name string
3296
3297                         //mt:len32
3298                         Data []byte
3299                 }
3300         }))(obj)).Files) = make([]struct {
3301                 Name string
3302                 Data []byte
3303         }, local100)
3304         for local101 := range (*(*(struct {
3305                 // N is the total number of ToCltMedia packets.
3306                 // I is the index of this packet.
3307                 N, I uint16
3308
3309                 //mt:len32
3310                 Files []struct {
3311                         Name string
3312
3313                         //mt:len32
3314                         Data []byte
3315                 }
3316         }))(obj)).Files {
3317                 var local102 []uint8
3318                 var local103 uint16
3319                 {
3320                         p := &local103
3321                         *p = read16(r)
3322                 }
3323                 (local102) = make([]uint8, local103)
3324                 {
3325                         _, err := io.ReadFull(r, (local102)[:])
3326                         chk(err)
3327                 }
3328                 ((((*(*(struct {
3329                         // N is the total number of ToCltMedia packets.
3330                         // I is the index of this packet.
3331                         N, I uint16
3332
3333                         //mt:len32
3334                         Files []struct {
3335                                 Name string
3336
3337                                 //mt:len32
3338                                 Data []byte
3339                         }
3340                 }))(obj)).Files)[local101]).Name) = string(local102)
3341                 var local104 uint32
3342                 {
3343                         p := &local104
3344                         *p = read32(r)
3345                 }
3346                 ((((*(*(struct {
3347                         // N is the total number of ToCltMedia packets.
3348                         // I is the index of this packet.
3349                         N, I uint16
3350
3351                         //mt:len32
3352                         Files []struct {
3353                                 Name string
3354
3355                                 //mt:len32
3356                                 Data []byte
3357                         }
3358                 }))(obj)).Files)[local101]).Data) = make([]byte, local104)
3359                 {
3360                         _, err := io.ReadFull(r, ((((*(*(struct {
3361                                 // N is the total number of ToCltMedia packets.
3362                                 // I is the index of this packet.
3363                                 N, I uint16
3364
3365                                 //mt:len32
3366                                 Files []struct {
3367                                         Name string
3368
3369                                         //mt:len32
3370                                         Data []byte
3371                                 }
3372                         }))(obj)).Files)[local101]).Data)[:])
3373                         chk(err)
3374                 }
3375         }
3376 }
3377
3378 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3379         {
3380                 ow := w
3381                 w := new(bytes.Buffer)
3382                 {
3383                         w := zlib.NewWriter(w)
3384                         {
3385                                 local105 := uint8(1)
3386                                 {
3387                                         x := local105
3388                                         write8(w, uint8(x))
3389                                 }
3390                         }
3391                         {
3392                                 x := (*(*(struct {
3393
3394                                         // See (de)serialize.fmt.
3395                                         Defs []NodeDef
3396                                 }))(obj)).Defs
3397                                 { // For ToCltNodeDefs.Defs.
3398                                         if len(x) > math.MaxUint16 {
3399                                                 chk(ErrTooLong)
3400                                         }
3401                                         write16(w, uint16(len(x)))
3402                                         var b bytes.Buffer
3403                                         for i := range x {
3404                                                 x[i].serialize(&b)
3405                                         }
3406                                         if b.Len() > math.MaxUint32 {
3407                                                 chk(ErrTooLong)
3408                                         }
3409                                         write32(w, uint32(b.Len()))
3410                                         _, err := b.WriteTo(w)
3411                                         chk(err)
3412                                 }
3413                         }
3414                         chk(w.Close())
3415                 }
3416                 {
3417                         buf := w
3418                         w := ow
3419                         if len((buf.Bytes())) > math.MaxUint32 {
3420                                 chk(ErrTooLong)
3421                         }
3422                         {
3423                                 x := uint32(len((buf.Bytes())))
3424                                 write32(w, uint32(x))
3425                         }
3426                         {
3427                                 _, err := w.Write((buf.Bytes())[:])
3428                                 chk(err)
3429                         }
3430                 }
3431         }
3432 }
3433
3434 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3435         {
3436                 var n uint32
3437                 {
3438                         p := &n
3439                         *p = read32(r)
3440                 }
3441                 r := &io.LimitedReader{R: r, N: int64(n)}
3442                 {
3443                         r, err := zlib.NewReader(byteReader{r})
3444                         chk(err)
3445                         {
3446                                 var local106 uint8
3447                                 local107 := uint8(1)
3448                                 {
3449                                         p := &local106
3450                                         *p = read8(r)
3451                                 }
3452                                 if local106 != local107 {
3453                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local106))
3454                                 }
3455                         }
3456                         {
3457                                 p := &(*(*(struct {
3458
3459                                         // See (de)serialize.fmt.
3460                                         Defs []NodeDef
3461                                 }))(obj)).Defs
3462                                 { // For ToCltNodeDefs.Defs.
3463                                         *p = make([]NodeDef, read16(r))
3464                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3465                                         for i := range *p {
3466                                                 (*p)[i].deserialize(r)
3467                                         }
3468                                         if r.N > 0 {
3469                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3470                                         }
3471                                 }
3472                         }
3473                         chk(r.Close())
3474                 }
3475                 if r.N > 0 {
3476                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3477                 }
3478         }
3479 }
3480
3481 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3482         if len(((*(*(struct {
3483                 Files []struct {
3484                         Name       string
3485                         Base64SHA1 string
3486                 }
3487                 URL string
3488         }))(obj)).Files)) > math.MaxUint16 {
3489                 chk(ErrTooLong)
3490         }
3491         {
3492                 x := uint16(len(((*(*(struct {
3493                         Files []struct {
3494                                 Name       string
3495                                 Base64SHA1 string
3496                         }
3497                         URL string
3498                 }))(obj)).Files)))
3499                 write16(w, uint16(x))
3500         }
3501         for local108 := range (*(*(struct {
3502                 Files []struct {
3503                         Name       string
3504                         Base64SHA1 string
3505                 }
3506                 URL string
3507         }))(obj)).Files {
3508                 if len(([]byte((((*(*(struct {
3509                         Files []struct {
3510                                 Name       string
3511                                 Base64SHA1 string
3512                         }
3513                         URL string
3514                 }))(obj)).Files)[local108]).Name))) > math.MaxUint16 {
3515                         chk(ErrTooLong)
3516                 }
3517                 {
3518                         x := uint16(len(([]byte((((*(*(struct {
3519                                 Files []struct {
3520                                         Name       string
3521                                         Base64SHA1 string
3522                                 }
3523                                 URL string
3524                         }))(obj)).Files)[local108]).Name))))
3525                         write16(w, uint16(x))
3526                 }
3527                 {
3528                         _, err := w.Write(([]byte((((*(*(struct {
3529                                 Files []struct {
3530                                         Name       string
3531                                         Base64SHA1 string
3532                                 }
3533                                 URL string
3534                         }))(obj)).Files)[local108]).Name))[:])
3535                         chk(err)
3536                 }
3537                 if len(([]byte((((*(*(struct {
3538                         Files []struct {
3539                                 Name       string
3540                                 Base64SHA1 string
3541                         }
3542                         URL string
3543                 }))(obj)).Files)[local108]).Base64SHA1))) > math.MaxUint16 {
3544                         chk(ErrTooLong)
3545                 }
3546                 {
3547                         x := uint16(len(([]byte((((*(*(struct {
3548                                 Files []struct {
3549                                         Name       string
3550                                         Base64SHA1 string
3551                                 }
3552                                 URL string
3553                         }))(obj)).Files)[local108]).Base64SHA1))))
3554                         write16(w, uint16(x))
3555                 }
3556                 {
3557                         _, err := w.Write(([]byte((((*(*(struct {
3558                                 Files []struct {
3559                                         Name       string
3560                                         Base64SHA1 string
3561                                 }
3562                                 URL string
3563                         }))(obj)).Files)[local108]).Base64SHA1))[:])
3564                         chk(err)
3565                 }
3566         }
3567         if len(([]byte((*(*(struct {
3568                 Files []struct {
3569                         Name       string
3570                         Base64SHA1 string
3571                 }
3572                 URL string
3573         }))(obj)).URL))) > math.MaxUint16 {
3574                 chk(ErrTooLong)
3575         }
3576         {
3577                 x := uint16(len(([]byte((*(*(struct {
3578                         Files []struct {
3579                                 Name       string
3580                                 Base64SHA1 string
3581                         }
3582                         URL string
3583                 }))(obj)).URL))))
3584                 write16(w, uint16(x))
3585         }
3586         {
3587                 _, err := w.Write(([]byte((*(*(struct {
3588                         Files []struct {
3589                                 Name       string
3590                                 Base64SHA1 string
3591                         }
3592                         URL string
3593                 }))(obj)).URL))[:])
3594                 chk(err)
3595         }
3596 }
3597
3598 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3599         var local109 uint16
3600         {
3601                 p := &local109
3602                 *p = read16(r)
3603         }
3604         ((*(*(struct {
3605                 Files []struct {
3606                         Name       string
3607                         Base64SHA1 string
3608                 }
3609                 URL string
3610         }))(obj)).Files) = make([]struct {
3611                 Name       string
3612                 Base64SHA1 string
3613         }, local109)
3614         for local110 := range (*(*(struct {
3615                 Files []struct {
3616                         Name       string
3617                         Base64SHA1 string
3618                 }
3619                 URL string
3620         }))(obj)).Files {
3621                 var local111 []uint8
3622                 var local112 uint16
3623                 {
3624                         p := &local112
3625                         *p = read16(r)
3626                 }
3627                 (local111) = make([]uint8, local112)
3628                 {
3629                         _, err := io.ReadFull(r, (local111)[:])
3630                         chk(err)
3631                 }
3632                 ((((*(*(struct {
3633                         Files []struct {
3634                                 Name       string
3635                                 Base64SHA1 string
3636                         }
3637                         URL string
3638                 }))(obj)).Files)[local110]).Name) = string(local111)
3639                 var local113 []uint8
3640                 var local114 uint16
3641                 {
3642                         p := &local114
3643                         *p = read16(r)
3644                 }
3645                 (local113) = make([]uint8, local114)
3646                 {
3647                         _, err := io.ReadFull(r, (local113)[:])
3648                         chk(err)
3649                 }
3650                 ((((*(*(struct {
3651                         Files []struct {
3652                                 Name       string
3653                                 Base64SHA1 string
3654                         }
3655                         URL string
3656                 }))(obj)).Files)[local110]).Base64SHA1) = string(local113)
3657         }
3658         var local115 []uint8
3659         var local116 uint16
3660         {
3661                 p := &local116
3662                 *p = read16(r)
3663         }
3664         (local115) = make([]uint8, local116)
3665         {
3666                 _, err := io.ReadFull(r, (local115)[:])
3667                 chk(err)
3668         }
3669         ((*(*(struct {
3670                 Files []struct {
3671                         Name       string
3672                         Base64SHA1 string
3673                 }
3674                 URL string
3675         }))(obj)).URL) = string(local115)
3676 }
3677
3678 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3679         {
3680                 ow := w
3681                 w := new(bytes.Buffer)
3682                 {
3683                         w := zlib.NewWriter(w)
3684                         {
3685                                 local117 := uint8(0)
3686                                 {
3687                                         x := local117
3688                                         write8(w, uint8(x))
3689                                 }
3690                         }
3691                         if len(((*(*(struct {
3692                                 Defs    []ItemDef
3693                                 Aliases []struct{ Alias, Orig string }
3694                         }))(obj)).Defs)) > math.MaxUint16 {
3695                                 chk(ErrTooLong)
3696                         }
3697                         {
3698                                 x := uint16(len(((*(*(struct {
3699                                         Defs    []ItemDef
3700                                         Aliases []struct{ Alias, Orig string }
3701                                 }))(obj)).Defs)))
3702                                 write16(w, uint16(x))
3703                         }
3704                         for local118 := range (*(*(struct {
3705                                 Defs    []ItemDef
3706                                 Aliases []struct{ Alias, Orig string }
3707                         }))(obj)).Defs {
3708                                 if err := pcall(func() {
3709                                         (((*(*(struct {
3710                                                 Defs    []ItemDef
3711                                                 Aliases []struct{ Alias, Orig string }
3712                                         }))(obj)).Defs)[local118]).serialize(w)
3713                                 }); err != nil {
3714                                         if err == io.EOF {
3715                                                 chk(io.EOF)
3716                                         }
3717                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3718                                 }
3719                         }
3720                         if len(((*(*(struct {
3721                                 Defs    []ItemDef
3722                                 Aliases []struct{ Alias, Orig string }
3723                         }))(obj)).Aliases)) > math.MaxUint16 {
3724                                 chk(ErrTooLong)
3725                         }
3726                         {
3727                                 x := uint16(len(((*(*(struct {
3728                                         Defs    []ItemDef
3729                                         Aliases []struct{ Alias, Orig string }
3730                                 }))(obj)).Aliases)))
3731                                 write16(w, uint16(x))
3732                         }
3733                         for local119 := range (*(*(struct {
3734                                 Defs    []ItemDef
3735                                 Aliases []struct{ Alias, Orig string }
3736                         }))(obj)).Aliases {
3737                                 if len(([]byte((((*(*(struct {
3738                                         Defs    []ItemDef
3739                                         Aliases []struct{ Alias, Orig string }
3740                                 }))(obj)).Aliases)[local119]).Alias))) > math.MaxUint16 {
3741                                         chk(ErrTooLong)
3742                                 }
3743                                 {
3744                                         x := uint16(len(([]byte((((*(*(struct {
3745                                                 Defs    []ItemDef
3746                                                 Aliases []struct{ Alias, Orig string }
3747                                         }))(obj)).Aliases)[local119]).Alias))))
3748                                         write16(w, uint16(x))
3749                                 }
3750                                 {
3751                                         _, err := w.Write(([]byte((((*(*(struct {
3752                                                 Defs    []ItemDef
3753                                                 Aliases []struct{ Alias, Orig string }
3754                                         }))(obj)).Aliases)[local119]).Alias))[:])
3755                                         chk(err)
3756                                 }
3757                                 if len(([]byte((((*(*(struct {
3758                                         Defs    []ItemDef
3759                                         Aliases []struct{ Alias, Orig string }
3760                                 }))(obj)).Aliases)[local119]).Orig))) > math.MaxUint16 {
3761                                         chk(ErrTooLong)
3762                                 }
3763                                 {
3764                                         x := uint16(len(([]byte((((*(*(struct {
3765                                                 Defs    []ItemDef
3766                                                 Aliases []struct{ Alias, Orig string }
3767                                         }))(obj)).Aliases)[local119]).Orig))))
3768                                         write16(w, uint16(x))
3769                                 }
3770                                 {
3771                                         _, err := w.Write(([]byte((((*(*(struct {
3772                                                 Defs    []ItemDef
3773                                                 Aliases []struct{ Alias, Orig string }
3774                                         }))(obj)).Aliases)[local119]).Orig))[:])
3775                                         chk(err)
3776                                 }
3777                         }
3778                         chk(w.Close())
3779                 }
3780                 {
3781                         buf := w
3782                         w := ow
3783                         if len((buf.Bytes())) > math.MaxUint32 {
3784                                 chk(ErrTooLong)
3785                         }
3786                         {
3787                                 x := uint32(len((buf.Bytes())))
3788                                 write32(w, uint32(x))
3789                         }
3790                         {
3791                                 _, err := w.Write((buf.Bytes())[:])
3792                                 chk(err)
3793                         }
3794                 }
3795         }
3796 }
3797
3798 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
3799         {
3800                 var n uint32
3801                 {
3802                         p := &n
3803                         *p = read32(r)
3804                 }
3805                 r := &io.LimitedReader{R: r, N: int64(n)}
3806                 {
3807                         r, err := zlib.NewReader(byteReader{r})
3808                         chk(err)
3809                         {
3810                                 var local120 uint8
3811                                 local121 := uint8(0)
3812                                 {
3813                                         p := &local120
3814                                         *p = read8(r)
3815                                 }
3816                                 if local120 != local121 {
3817                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local120))
3818                                 }
3819                         }
3820                         var local122 uint16
3821                         {
3822                                 p := &local122
3823                                 *p = read16(r)
3824                         }
3825                         ((*(*(struct {
3826                                 Defs    []ItemDef
3827                                 Aliases []struct{ Alias, Orig string }
3828                         }))(obj)).Defs) = make([]ItemDef, local122)
3829                         for local123 := range (*(*(struct {
3830                                 Defs    []ItemDef
3831                                 Aliases []struct{ Alias, Orig string }
3832                         }))(obj)).Defs {
3833                                 if err := pcall(func() {
3834                                         (((*(*(struct {
3835                                                 Defs    []ItemDef
3836                                                 Aliases []struct{ Alias, Orig string }
3837                                         }))(obj)).Defs)[local123]).deserialize(r)
3838                                 }); err != nil {
3839                                         if err == io.EOF {
3840                                                 chk(io.EOF)
3841                                         }
3842                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3843                                 }
3844                         }
3845                         var local124 uint16
3846                         {
3847                                 p := &local124
3848                                 *p = read16(r)
3849                         }
3850                         ((*(*(struct {
3851                                 Defs    []ItemDef
3852                                 Aliases []struct{ Alias, Orig string }
3853                         }))(obj)).Aliases) = make([]struct {
3854                                 Alias string
3855                                 Orig  string
3856                         }, local124)
3857                         for local125 := range (*(*(struct {
3858                                 Defs    []ItemDef
3859                                 Aliases []struct{ Alias, Orig string }
3860                         }))(obj)).Aliases {
3861                                 var local126 []uint8
3862                                 var local127 uint16
3863                                 {
3864                                         p := &local127
3865                                         *p = read16(r)
3866                                 }
3867                                 (local126) = make([]uint8, local127)
3868                                 {
3869                                         _, err := io.ReadFull(r, (local126)[:])
3870                                         chk(err)
3871                                 }
3872                                 ((((*(*(struct {
3873                                         Defs    []ItemDef
3874                                         Aliases []struct{ Alias, Orig string }
3875                                 }))(obj)).Aliases)[local125]).Alias) = string(local126)
3876                                 var local128 []uint8
3877                                 var local129 uint16
3878                                 {
3879                                         p := &local129
3880                                         *p = read16(r)
3881                                 }
3882                                 (local128) = make([]uint8, local129)
3883                                 {
3884                                         _, err := io.ReadFull(r, (local128)[:])
3885                                         chk(err)
3886                                 }
3887                                 ((((*(*(struct {
3888                                         Defs    []ItemDef
3889                                         Aliases []struct{ Alias, Orig string }
3890                                 }))(obj)).Aliases)[local125]).Orig) = string(local128)
3891                         }
3892                         chk(r.Close())
3893                 }
3894                 if r.N > 0 {
3895                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3896                 }
3897         }
3898 }
3899
3900 func (obj *ToCltPlaySound) serialize(w io.Writer) {
3901         if err := pcall(func() {
3902                 ((*(*(struct {
3903                         ID      SoundID
3904                         Name    string
3905                         Gain    float32
3906                         SrcType SoundSrcType
3907                         Pos
3908                         SrcAOID   AOID
3909                         Loop      bool
3910                         Fade      float32
3911                         Pitch     float32
3912                         Ephemeral bool
3913                 }))(obj)).ID).serialize(w)
3914         }); err != nil {
3915                 if err == io.EOF {
3916                         chk(io.EOF)
3917                 }
3918                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
3919         }
3920         if len(([]byte((*(*(struct {
3921                 ID      SoundID
3922                 Name    string
3923                 Gain    float32
3924                 SrcType SoundSrcType
3925                 Pos
3926                 SrcAOID   AOID
3927                 Loop      bool
3928                 Fade      float32
3929                 Pitch     float32
3930                 Ephemeral bool
3931         }))(obj)).Name))) > math.MaxUint16 {
3932                 chk(ErrTooLong)
3933         }
3934         {
3935                 x := uint16(len(([]byte((*(*(struct {
3936                         ID      SoundID
3937                         Name    string
3938                         Gain    float32
3939                         SrcType SoundSrcType
3940                         Pos
3941                         SrcAOID   AOID
3942                         Loop      bool
3943                         Fade      float32
3944                         Pitch     float32
3945                         Ephemeral bool
3946                 }))(obj)).Name))))
3947                 write16(w, uint16(x))
3948         }
3949         {
3950                 _, err := w.Write(([]byte((*(*(struct {
3951                         ID      SoundID
3952                         Name    string
3953                         Gain    float32
3954                         SrcType SoundSrcType
3955                         Pos
3956                         SrcAOID   AOID
3957                         Loop      bool
3958                         Fade      float32
3959                         Pitch     float32
3960                         Ephemeral bool
3961                 }))(obj)).Name))[:])
3962                 chk(err)
3963         }
3964         {
3965                 x := (*(*(struct {
3966                         ID      SoundID
3967                         Name    string
3968                         Gain    float32
3969                         SrcType SoundSrcType
3970                         Pos
3971                         SrcAOID   AOID
3972                         Loop      bool
3973                         Fade      float32
3974                         Pitch     float32
3975                         Ephemeral bool
3976                 }))(obj)).Gain
3977                 write32(w, math.Float32bits(x))
3978         }
3979         if err := pcall(func() {
3980                 ((*(*(struct {
3981                         ID      SoundID
3982                         Name    string
3983                         Gain    float32
3984                         SrcType SoundSrcType
3985                         Pos
3986                         SrcAOID   AOID
3987                         Loop      bool
3988                         Fade      float32
3989                         Pitch     float32
3990                         Ephemeral bool
3991                 }))(obj)).SrcType).serialize(w)
3992         }); err != nil {
3993                 if err == io.EOF {
3994                         chk(io.EOF)
3995                 }
3996                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
3997         }
3998         if err := pcall(func() {
3999                 ((*(*(struct {
4000                         ID      SoundID
4001                         Name    string
4002                         Gain    float32
4003                         SrcType SoundSrcType
4004                         Pos
4005                         SrcAOID   AOID
4006                         Loop      bool
4007                         Fade      float32
4008                         Pitch     float32
4009                         Ephemeral bool
4010                 }))(obj)).Pos).serialize(w)
4011         }); err != nil {
4012                 if err == io.EOF {
4013                         chk(io.EOF)
4014                 }
4015                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4016         }
4017         if err := pcall(func() {
4018                 ((*(*(struct {
4019                         ID      SoundID
4020                         Name    string
4021                         Gain    float32
4022                         SrcType SoundSrcType
4023                         Pos
4024                         SrcAOID   AOID
4025                         Loop      bool
4026                         Fade      float32
4027                         Pitch     float32
4028                         Ephemeral bool
4029                 }))(obj)).SrcAOID).serialize(w)
4030         }); err != nil {
4031                 if err == io.EOF {
4032                         chk(io.EOF)
4033                 }
4034                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4035         }
4036         {
4037                 x := (*(*(struct {
4038                         ID      SoundID
4039                         Name    string
4040                         Gain    float32
4041                         SrcType SoundSrcType
4042                         Pos
4043                         SrcAOID   AOID
4044                         Loop      bool
4045                         Fade      float32
4046                         Pitch     float32
4047                         Ephemeral bool
4048                 }))(obj)).Loop
4049                 if x {
4050                         write8(w, 1)
4051                 } else {
4052                         write8(w, 0)
4053                 }
4054         }
4055         {
4056                 x := (*(*(struct {
4057                         ID      SoundID
4058                         Name    string
4059                         Gain    float32
4060                         SrcType SoundSrcType
4061                         Pos
4062                         SrcAOID   AOID
4063                         Loop      bool
4064                         Fade      float32
4065                         Pitch     float32
4066                         Ephemeral bool
4067                 }))(obj)).Fade
4068                 write32(w, math.Float32bits(x))
4069         }
4070         {
4071                 x := (*(*(struct {
4072                         ID      SoundID
4073                         Name    string
4074                         Gain    float32
4075                         SrcType SoundSrcType
4076                         Pos
4077                         SrcAOID   AOID
4078                         Loop      bool
4079                         Fade      float32
4080                         Pitch     float32
4081                         Ephemeral bool
4082                 }))(obj)).Pitch
4083                 write32(w, math.Float32bits(x))
4084         }
4085         {
4086                 x := (*(*(struct {
4087                         ID      SoundID
4088                         Name    string
4089                         Gain    float32
4090                         SrcType SoundSrcType
4091                         Pos
4092                         SrcAOID   AOID
4093                         Loop      bool
4094                         Fade      float32
4095                         Pitch     float32
4096                         Ephemeral bool
4097                 }))(obj)).Ephemeral
4098                 if x {
4099                         write8(w, 1)
4100                 } else {
4101                         write8(w, 0)
4102                 }
4103         }
4104 }
4105
4106 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4107         if err := pcall(func() {
4108                 ((*(*(struct {
4109                         ID      SoundID
4110                         Name    string
4111                         Gain    float32
4112                         SrcType SoundSrcType
4113                         Pos
4114                         SrcAOID   AOID
4115                         Loop      bool
4116                         Fade      float32
4117                         Pitch     float32
4118                         Ephemeral bool
4119                 }))(obj)).ID).deserialize(r)
4120         }); err != nil {
4121                 if err == io.EOF {
4122                         chk(io.EOF)
4123                 }
4124                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4125         }
4126         var local130 []uint8
4127         var local131 uint16
4128         {
4129                 p := &local131
4130                 *p = read16(r)
4131         }
4132         (local130) = make([]uint8, local131)
4133         {
4134                 _, err := io.ReadFull(r, (local130)[:])
4135                 chk(err)
4136         }
4137         ((*(*(struct {
4138                 ID      SoundID
4139                 Name    string
4140                 Gain    float32
4141                 SrcType SoundSrcType
4142                 Pos
4143                 SrcAOID   AOID
4144                 Loop      bool
4145                 Fade      float32
4146                 Pitch     float32
4147                 Ephemeral bool
4148         }))(obj)).Name) = string(local130)
4149         {
4150                 p := &(*(*(struct {
4151                         ID      SoundID
4152                         Name    string
4153                         Gain    float32
4154                         SrcType SoundSrcType
4155                         Pos
4156                         SrcAOID   AOID
4157                         Loop      bool
4158                         Fade      float32
4159                         Pitch     float32
4160                         Ephemeral bool
4161                 }))(obj)).Gain
4162                 *p = math.Float32frombits(read32(r))
4163         }
4164         if err := pcall(func() {
4165                 ((*(*(struct {
4166                         ID      SoundID
4167                         Name    string
4168                         Gain    float32
4169                         SrcType SoundSrcType
4170                         Pos
4171                         SrcAOID   AOID
4172                         Loop      bool
4173                         Fade      float32
4174                         Pitch     float32
4175                         Ephemeral bool
4176                 }))(obj)).SrcType).deserialize(r)
4177         }); err != nil {
4178                 if err == io.EOF {
4179                         chk(io.EOF)
4180                 }
4181                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
4182         }
4183         if err := pcall(func() {
4184                 ((*(*(struct {
4185                         ID      SoundID
4186                         Name    string
4187                         Gain    float32
4188                         SrcType SoundSrcType
4189                         Pos
4190                         SrcAOID   AOID
4191                         Loop      bool
4192                         Fade      float32
4193                         Pitch     float32
4194                         Ephemeral bool
4195                 }))(obj)).Pos).deserialize(r)
4196         }); err != nil {
4197                 if err == io.EOF {
4198                         chk(io.EOF)
4199                 }
4200                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4201         }
4202         if err := pcall(func() {
4203                 ((*(*(struct {
4204                         ID      SoundID
4205                         Name    string
4206                         Gain    float32
4207                         SrcType SoundSrcType
4208                         Pos
4209                         SrcAOID   AOID
4210                         Loop      bool
4211                         Fade      float32
4212                         Pitch     float32
4213                         Ephemeral bool
4214                 }))(obj)).SrcAOID).deserialize(r)
4215         }); err != nil {
4216                 if err == io.EOF {
4217                         chk(io.EOF)
4218                 }
4219                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4220         }
4221         {
4222                 p := &(*(*(struct {
4223                         ID      SoundID
4224                         Name    string
4225                         Gain    float32
4226                         SrcType SoundSrcType
4227                         Pos
4228                         SrcAOID   AOID
4229                         Loop      bool
4230                         Fade      float32
4231                         Pitch     float32
4232                         Ephemeral bool
4233                 }))(obj)).Loop
4234                 switch n := read8(r); n {
4235                 case 0:
4236                         *p = false
4237                 case 1:
4238                         *p = true
4239                 default:
4240                         chk(fmt.Errorf("invalid bool: %d", n))
4241                 }
4242         }
4243         {
4244                 p := &(*(*(struct {
4245                         ID      SoundID
4246                         Name    string
4247                         Gain    float32
4248                         SrcType SoundSrcType
4249                         Pos
4250                         SrcAOID   AOID
4251                         Loop      bool
4252                         Fade      float32
4253                         Pitch     float32
4254                         Ephemeral bool
4255                 }))(obj)).Fade
4256                 *p = math.Float32frombits(read32(r))
4257         }
4258         {
4259                 p := &(*(*(struct {
4260                         ID      SoundID
4261                         Name    string
4262                         Gain    float32
4263                         SrcType SoundSrcType
4264                         Pos
4265                         SrcAOID   AOID
4266                         Loop      bool
4267                         Fade      float32
4268                         Pitch     float32
4269                         Ephemeral bool
4270                 }))(obj)).Pitch
4271                 *p = math.Float32frombits(read32(r))
4272         }
4273         {
4274                 p := &(*(*(struct {
4275                         ID      SoundID
4276                         Name    string
4277                         Gain    float32
4278                         SrcType SoundSrcType
4279                         Pos
4280                         SrcAOID   AOID
4281                         Loop      bool
4282                         Fade      float32
4283                         Pitch     float32
4284                         Ephemeral bool
4285                 }))(obj)).Ephemeral
4286                 switch n := read8(r); n {
4287                 case 0:
4288                         *p = false
4289                 case 1:
4290                         *p = true
4291                 default:
4292                         chk(fmt.Errorf("invalid bool: %d", n))
4293                 }
4294         }
4295 }
4296
4297 func (obj *ToCltStopSound) serialize(w io.Writer) {
4298         if err := pcall(func() {
4299                 ((*(*(struct {
4300                         ID SoundID
4301                 }))(obj)).ID).serialize(w)
4302         }); err != nil {
4303                 if err == io.EOF {
4304                         chk(io.EOF)
4305                 }
4306                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4307         }
4308 }
4309
4310 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4311         if err := pcall(func() {
4312                 ((*(*(struct {
4313                         ID SoundID
4314                 }))(obj)).ID).deserialize(r)
4315         }); err != nil {
4316                 if err == io.EOF {
4317                         chk(io.EOF)
4318                 }
4319                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4320         }
4321 }
4322
4323 func (obj *ToCltPrivs) serialize(w io.Writer) {
4324         if len(((*(*(struct {
4325                 Privs []string
4326         }))(obj)).Privs)) > math.MaxUint16 {
4327                 chk(ErrTooLong)
4328         }
4329         {
4330                 x := uint16(len(((*(*(struct {
4331                         Privs []string
4332                 }))(obj)).Privs)))
4333                 write16(w, uint16(x))
4334         }
4335         for local132 := range (*(*(struct {
4336                 Privs []string
4337         }))(obj)).Privs {
4338                 if len(([]byte(((*(*(struct {
4339                         Privs []string
4340                 }))(obj)).Privs)[local132]))) > math.MaxUint16 {
4341                         chk(ErrTooLong)
4342                 }
4343                 {
4344                         x := uint16(len(([]byte(((*(*(struct {
4345                                 Privs []string
4346                         }))(obj)).Privs)[local132]))))
4347                         write16(w, uint16(x))
4348                 }
4349                 {
4350                         _, err := w.Write(([]byte(((*(*(struct {
4351                                 Privs []string
4352                         }))(obj)).Privs)[local132]))[:])
4353                         chk(err)
4354                 }
4355         }
4356 }
4357
4358 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4359         var local133 uint16
4360         {
4361                 p := &local133
4362                 *p = read16(r)
4363         }
4364         ((*(*(struct {
4365                 Privs []string
4366         }))(obj)).Privs) = make([]string, local133)
4367         for local134 := range (*(*(struct {
4368                 Privs []string
4369         }))(obj)).Privs {
4370                 var local135 []uint8
4371                 var local136 uint16
4372                 {
4373                         p := &local136
4374                         *p = read16(r)
4375                 }
4376                 (local135) = make([]uint8, local136)
4377                 {
4378                         _, err := io.ReadFull(r, (local135)[:])
4379                         chk(err)
4380                 }
4381                 (((*(*(struct {
4382                         Privs []string
4383                 }))(obj)).Privs)[local134]) = string(local135)
4384         }
4385 }
4386
4387 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4388         if len(([]byte((*(*(struct {
4389                 //mt:len32
4390                 Formspec string
4391         }))(obj)).Formspec))) > math.MaxUint32 {
4392                 chk(ErrTooLong)
4393         }
4394         {
4395                 x := uint32(len(([]byte((*(*(struct {
4396                         //mt:len32
4397                         Formspec string
4398                 }))(obj)).Formspec))))
4399                 write32(w, uint32(x))
4400         }
4401         {
4402                 _, err := w.Write(([]byte((*(*(struct {
4403                         //mt:len32
4404                         Formspec string
4405                 }))(obj)).Formspec))[:])
4406                 chk(err)
4407         }
4408 }
4409
4410 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4411         var local137 []uint8
4412         var local138 uint32
4413         {
4414                 p := &local138
4415                 *p = read32(r)
4416         }
4417         (local137) = make([]uint8, local138)
4418         {
4419                 _, err := io.ReadFull(r, (local137)[:])
4420                 chk(err)
4421         }
4422         ((*(*(struct {
4423                 //mt:len32
4424                 Formspec string
4425         }))(obj)).Formspec) = string(local137)
4426 }
4427
4428 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4429         if len(([]byte((*(*(struct {
4430                 Name string
4431                 Keep bool
4432                 Len  uint16 // deprecated
4433
4434                 //mt:raw
4435                 Inv string
4436         }))(obj)).Name))) > math.MaxUint16 {
4437                 chk(ErrTooLong)
4438         }
4439         {
4440                 x := uint16(len(([]byte((*(*(struct {
4441                         Name string
4442                         Keep bool
4443                         Len  uint16 // deprecated
4444
4445                         //mt:raw
4446                         Inv string
4447                 }))(obj)).Name))))
4448                 write16(w, uint16(x))
4449         }
4450         {
4451                 _, err := w.Write(([]byte((*(*(struct {
4452                         Name string
4453                         Keep bool
4454                         Len  uint16 // deprecated
4455
4456                         //mt:raw
4457                         Inv string
4458                 }))(obj)).Name))[:])
4459                 chk(err)
4460         }
4461         {
4462                 x := (*(*(struct {
4463                         Name string
4464                         Keep bool
4465                         Len  uint16 // deprecated
4466
4467                         //mt:raw
4468                         Inv string
4469                 }))(obj)).Keep
4470                 if x {
4471                         write8(w, 1)
4472                 } else {
4473                         write8(w, 0)
4474                 }
4475         }
4476         {
4477                 x := (*(*(struct {
4478                         Name string
4479                         Keep bool
4480                         Len  uint16 // deprecated
4481
4482                         //mt:raw
4483                         Inv string
4484                 }))(obj)).Len
4485                 write16(w, uint16(x))
4486         }
4487         {
4488                 _, err := w.Write(([]byte((*(*(struct {
4489                         Name string
4490                         Keep bool
4491                         Len  uint16 // deprecated
4492
4493                         //mt:raw
4494                         Inv string
4495                 }))(obj)).Inv))[:])
4496                 chk(err)
4497         }
4498 }
4499
4500 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4501         var local139 []uint8
4502         var local140 uint16
4503         {
4504                 p := &local140
4505                 *p = read16(r)
4506         }
4507         (local139) = make([]uint8, local140)
4508         {
4509                 _, err := io.ReadFull(r, (local139)[:])
4510                 chk(err)
4511         }
4512         ((*(*(struct {
4513                 Name string
4514                 Keep bool
4515                 Len  uint16 // deprecated
4516
4517                 //mt:raw
4518                 Inv string
4519         }))(obj)).Name) = string(local139)
4520         {
4521                 p := &(*(*(struct {
4522                         Name string
4523                         Keep bool
4524                         Len  uint16 // deprecated
4525
4526                         //mt:raw
4527                         Inv string
4528                 }))(obj)).Keep
4529                 switch n := read8(r); n {
4530                 case 0:
4531                         *p = false
4532                 case 1:
4533                         *p = true
4534                 default:
4535                         chk(fmt.Errorf("invalid bool: %d", n))
4536                 }
4537         }
4538         {
4539                 p := &(*(*(struct {
4540                         Name string
4541                         Keep bool
4542                         Len  uint16 // deprecated
4543
4544                         //mt:raw
4545                         Inv string
4546                 }))(obj)).Len
4547                 *p = read16(r)
4548         }
4549         var local141 []uint8
4550         {
4551                 var err error
4552                 (local141), err = io.ReadAll(r)
4553                 chk(err)
4554         }
4555         ((*(*(struct {
4556                 Name string
4557                 Keep bool
4558                 Len  uint16 // deprecated
4559
4560                 //mt:raw
4561                 Inv string
4562         }))(obj)).Inv) = string(local141)
4563 }
4564
4565 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4566         if len(([]byte((*(*(struct {
4567                 //mt:len32
4568                 Formspec string
4569
4570                 Formname string
4571         }))(obj)).Formspec))) > math.MaxUint32 {
4572                 chk(ErrTooLong)
4573         }
4574         {
4575                 x := uint32(len(([]byte((*(*(struct {
4576                         //mt:len32
4577                         Formspec string
4578
4579                         Formname string
4580                 }))(obj)).Formspec))))
4581                 write32(w, uint32(x))
4582         }
4583         {
4584                 _, err := w.Write(([]byte((*(*(struct {
4585                         //mt:len32
4586                         Formspec string
4587
4588                         Formname string
4589                 }))(obj)).Formspec))[:])
4590                 chk(err)
4591         }
4592         if len(([]byte((*(*(struct {
4593                 //mt:len32
4594                 Formspec string
4595
4596                 Formname string
4597         }))(obj)).Formname))) > math.MaxUint16 {
4598                 chk(ErrTooLong)
4599         }
4600         {
4601                 x := uint16(len(([]byte((*(*(struct {
4602                         //mt:len32
4603                         Formspec string
4604
4605                         Formname string
4606                 }))(obj)).Formname))))
4607                 write16(w, uint16(x))
4608         }
4609         {
4610                 _, err := w.Write(([]byte((*(*(struct {
4611                         //mt:len32
4612                         Formspec string
4613
4614                         Formname string
4615                 }))(obj)).Formname))[:])
4616                 chk(err)
4617         }
4618 }
4619
4620 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4621         var local142 []uint8
4622         var local143 uint32
4623         {
4624                 p := &local143
4625                 *p = read32(r)
4626         }
4627         (local142) = make([]uint8, local143)
4628         {
4629                 _, err := io.ReadFull(r, (local142)[:])
4630                 chk(err)
4631         }
4632         ((*(*(struct {
4633                 //mt:len32
4634                 Formspec string
4635
4636                 Formname string
4637         }))(obj)).Formspec) = string(local142)
4638         var local144 []uint8
4639         var local145 uint16
4640         {
4641                 p := &local145
4642                 *p = read16(r)
4643         }
4644         (local144) = make([]uint8, local145)
4645         {
4646                 _, err := io.ReadFull(r, (local144)[:])
4647                 chk(err)
4648         }
4649         ((*(*(struct {
4650                 //mt:len32
4651                 Formspec string
4652
4653                 Formname string
4654         }))(obj)).Formname) = string(local144)
4655 }
4656
4657 func (obj *ToCltMovement) serialize(w io.Writer) {
4658         {
4659                 x := (*(*(struct {
4660                         DefaultAccel, AirAccel, FastAccel,
4661                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4662                         Fluidity, Smoothing, Sink,
4663                         Gravity float32
4664                 }))(obj)).DefaultAccel
4665                 write32(w, math.Float32bits(x))
4666         }
4667         {
4668                 x := (*(*(struct {
4669                         DefaultAccel, AirAccel, FastAccel,
4670                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4671                         Fluidity, Smoothing, Sink,
4672                         Gravity float32
4673                 }))(obj)).AirAccel
4674                 write32(w, math.Float32bits(x))
4675         }
4676         {
4677                 x := (*(*(struct {
4678                         DefaultAccel, AirAccel, FastAccel,
4679                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4680                         Fluidity, Smoothing, Sink,
4681                         Gravity float32
4682                 }))(obj)).FastAccel
4683                 write32(w, math.Float32bits(x))
4684         }
4685         {
4686                 x := (*(*(struct {
4687                         DefaultAccel, AirAccel, FastAccel,
4688                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4689                         Fluidity, Smoothing, Sink,
4690                         Gravity float32
4691                 }))(obj)).WalkSpeed
4692                 write32(w, math.Float32bits(x))
4693         }
4694         {
4695                 x := (*(*(struct {
4696                         DefaultAccel, AirAccel, FastAccel,
4697                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4698                         Fluidity, Smoothing, Sink,
4699                         Gravity float32
4700                 }))(obj)).CrouchSpeed
4701                 write32(w, math.Float32bits(x))
4702         }
4703         {
4704                 x := (*(*(struct {
4705                         DefaultAccel, AirAccel, FastAccel,
4706                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4707                         Fluidity, Smoothing, Sink,
4708                         Gravity float32
4709                 }))(obj)).FastSpeed
4710                 write32(w, math.Float32bits(x))
4711         }
4712         {
4713                 x := (*(*(struct {
4714                         DefaultAccel, AirAccel, FastAccel,
4715                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4716                         Fluidity, Smoothing, Sink,
4717                         Gravity float32
4718                 }))(obj)).ClimbSpeed
4719                 write32(w, math.Float32bits(x))
4720         }
4721         {
4722                 x := (*(*(struct {
4723                         DefaultAccel, AirAccel, FastAccel,
4724                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4725                         Fluidity, Smoothing, Sink,
4726                         Gravity float32
4727                 }))(obj)).JumpSpeed
4728                 write32(w, math.Float32bits(x))
4729         }
4730         {
4731                 x := (*(*(struct {
4732                         DefaultAccel, AirAccel, FastAccel,
4733                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4734                         Fluidity, Smoothing, Sink,
4735                         Gravity float32
4736                 }))(obj)).Fluidity
4737                 write32(w, math.Float32bits(x))
4738         }
4739         {
4740                 x := (*(*(struct {
4741                         DefaultAccel, AirAccel, FastAccel,
4742                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4743                         Fluidity, Smoothing, Sink,
4744                         Gravity float32
4745                 }))(obj)).Smoothing
4746                 write32(w, math.Float32bits(x))
4747         }
4748         {
4749                 x := (*(*(struct {
4750                         DefaultAccel, AirAccel, FastAccel,
4751                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4752                         Fluidity, Smoothing, Sink,
4753                         Gravity float32
4754                 }))(obj)).Sink
4755                 write32(w, math.Float32bits(x))
4756         }
4757         {
4758                 x := (*(*(struct {
4759                         DefaultAccel, AirAccel, FastAccel,
4760                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4761                         Fluidity, Smoothing, Sink,
4762                         Gravity float32
4763                 }))(obj)).Gravity
4764                 write32(w, math.Float32bits(x))
4765         }
4766 }
4767
4768 func (obj *ToCltMovement) deserialize(r io.Reader) {
4769         {
4770                 p := &(*(*(struct {
4771                         DefaultAccel, AirAccel, FastAccel,
4772                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4773                         Fluidity, Smoothing, Sink,
4774                         Gravity float32
4775                 }))(obj)).DefaultAccel
4776                 *p = math.Float32frombits(read32(r))
4777         }
4778         {
4779                 p := &(*(*(struct {
4780                         DefaultAccel, AirAccel, FastAccel,
4781                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4782                         Fluidity, Smoothing, Sink,
4783                         Gravity float32
4784                 }))(obj)).AirAccel
4785                 *p = math.Float32frombits(read32(r))
4786         }
4787         {
4788                 p := &(*(*(struct {
4789                         DefaultAccel, AirAccel, FastAccel,
4790                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4791                         Fluidity, Smoothing, Sink,
4792                         Gravity float32
4793                 }))(obj)).FastAccel
4794                 *p = math.Float32frombits(read32(r))
4795         }
4796         {
4797                 p := &(*(*(struct {
4798                         DefaultAccel, AirAccel, FastAccel,
4799                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4800                         Fluidity, Smoothing, Sink,
4801                         Gravity float32
4802                 }))(obj)).WalkSpeed
4803                 *p = math.Float32frombits(read32(r))
4804         }
4805         {
4806                 p := &(*(*(struct {
4807                         DefaultAccel, AirAccel, FastAccel,
4808                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4809                         Fluidity, Smoothing, Sink,
4810                         Gravity float32
4811                 }))(obj)).CrouchSpeed
4812                 *p = math.Float32frombits(read32(r))
4813         }
4814         {
4815                 p := &(*(*(struct {
4816                         DefaultAccel, AirAccel, FastAccel,
4817                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4818                         Fluidity, Smoothing, Sink,
4819                         Gravity float32
4820                 }))(obj)).FastSpeed
4821                 *p = math.Float32frombits(read32(r))
4822         }
4823         {
4824                 p := &(*(*(struct {
4825                         DefaultAccel, AirAccel, FastAccel,
4826                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4827                         Fluidity, Smoothing, Sink,
4828                         Gravity float32
4829                 }))(obj)).ClimbSpeed
4830                 *p = math.Float32frombits(read32(r))
4831         }
4832         {
4833                 p := &(*(*(struct {
4834                         DefaultAccel, AirAccel, FastAccel,
4835                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4836                         Fluidity, Smoothing, Sink,
4837                         Gravity float32
4838                 }))(obj)).JumpSpeed
4839                 *p = math.Float32frombits(read32(r))
4840         }
4841         {
4842                 p := &(*(*(struct {
4843                         DefaultAccel, AirAccel, FastAccel,
4844                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4845                         Fluidity, Smoothing, Sink,
4846                         Gravity float32
4847                 }))(obj)).Fluidity
4848                 *p = math.Float32frombits(read32(r))
4849         }
4850         {
4851                 p := &(*(*(struct {
4852                         DefaultAccel, AirAccel, FastAccel,
4853                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4854                         Fluidity, Smoothing, Sink,
4855                         Gravity float32
4856                 }))(obj)).Smoothing
4857                 *p = math.Float32frombits(read32(r))
4858         }
4859         {
4860                 p := &(*(*(struct {
4861                         DefaultAccel, AirAccel, FastAccel,
4862                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4863                         Fluidity, Smoothing, Sink,
4864                         Gravity float32
4865                 }))(obj)).Sink
4866                 *p = math.Float32frombits(read32(r))
4867         }
4868         {
4869                 p := &(*(*(struct {
4870                         DefaultAccel, AirAccel, FastAccel,
4871                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4872                         Fluidity, Smoothing, Sink,
4873                         Gravity float32
4874                 }))(obj)).Gravity
4875                 *p = math.Float32frombits(read32(r))
4876         }
4877 }
4878
4879 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
4880         for local146 := range (*(*(struct {
4881                 Pos, Vel, Acc  [3]float32
4882                 ExpirationTime float32 // in seconds.
4883                 Size           float32
4884                 Collide        bool
4885
4886                 //mt:len32
4887                 Texture
4888
4889                 Vertical    bool
4890                 CollisionRm bool
4891                 AnimParams  TileAnim
4892                 Glow        uint8
4893                 AOCollision bool
4894                 NodeParam0  Content
4895                 NodeParam2  uint8
4896                 NodeTile    uint8
4897         }))(obj)).Pos {
4898                 {
4899                         x := ((*(*(struct {
4900                                 Pos, Vel, Acc  [3]float32
4901                                 ExpirationTime float32 // in seconds.
4902                                 Size           float32
4903                                 Collide        bool
4904
4905                                 //mt:len32
4906                                 Texture
4907
4908                                 Vertical    bool
4909                                 CollisionRm bool
4910                                 AnimParams  TileAnim
4911                                 Glow        uint8
4912                                 AOCollision bool
4913                                 NodeParam0  Content
4914                                 NodeParam2  uint8
4915                                 NodeTile    uint8
4916                         }))(obj)).Pos)[local146]
4917                         write32(w, math.Float32bits(x))
4918                 }
4919         }
4920         for local147 := range (*(*(struct {
4921                 Pos, Vel, Acc  [3]float32
4922                 ExpirationTime float32 // in seconds.
4923                 Size           float32
4924                 Collide        bool
4925
4926                 //mt:len32
4927                 Texture
4928
4929                 Vertical    bool
4930                 CollisionRm bool
4931                 AnimParams  TileAnim
4932                 Glow        uint8
4933                 AOCollision bool
4934                 NodeParam0  Content
4935                 NodeParam2  uint8
4936                 NodeTile    uint8
4937         }))(obj)).Vel {
4938                 {
4939                         x := ((*(*(struct {
4940                                 Pos, Vel, Acc  [3]float32
4941                                 ExpirationTime float32 // in seconds.
4942                                 Size           float32
4943                                 Collide        bool
4944
4945                                 //mt:len32
4946                                 Texture
4947
4948                                 Vertical    bool
4949                                 CollisionRm bool
4950                                 AnimParams  TileAnim
4951                                 Glow        uint8
4952                                 AOCollision bool
4953                                 NodeParam0  Content
4954                                 NodeParam2  uint8
4955                                 NodeTile    uint8
4956                         }))(obj)).Vel)[local147]
4957                         write32(w, math.Float32bits(x))
4958                 }
4959         }
4960         for local148 := range (*(*(struct {
4961                 Pos, Vel, Acc  [3]float32
4962                 ExpirationTime float32 // in seconds.
4963                 Size           float32
4964                 Collide        bool
4965
4966                 //mt:len32
4967                 Texture
4968
4969                 Vertical    bool
4970                 CollisionRm bool
4971                 AnimParams  TileAnim
4972                 Glow        uint8
4973                 AOCollision bool
4974                 NodeParam0  Content
4975                 NodeParam2  uint8
4976                 NodeTile    uint8
4977         }))(obj)).Acc {
4978                 {
4979                         x := ((*(*(struct {
4980                                 Pos, Vel, Acc  [3]float32
4981                                 ExpirationTime float32 // in seconds.
4982                                 Size           float32
4983                                 Collide        bool
4984
4985                                 //mt:len32
4986                                 Texture
4987
4988                                 Vertical    bool
4989                                 CollisionRm bool
4990                                 AnimParams  TileAnim
4991                                 Glow        uint8
4992                                 AOCollision bool
4993                                 NodeParam0  Content
4994                                 NodeParam2  uint8
4995                                 NodeTile    uint8
4996                         }))(obj)).Acc)[local148]
4997                         write32(w, math.Float32bits(x))
4998                 }
4999         }
5000         {
5001                 x := (*(*(struct {
5002                         Pos, Vel, Acc  [3]float32
5003                         ExpirationTime float32 // in seconds.
5004                         Size           float32
5005                         Collide        bool
5006
5007                         //mt:len32
5008                         Texture
5009
5010                         Vertical    bool
5011                         CollisionRm bool
5012                         AnimParams  TileAnim
5013                         Glow        uint8
5014                         AOCollision bool
5015                         NodeParam0  Content
5016                         NodeParam2  uint8
5017                         NodeTile    uint8
5018                 }))(obj)).ExpirationTime
5019                 write32(w, math.Float32bits(x))
5020         }
5021         {
5022                 x := (*(*(struct {
5023                         Pos, Vel, Acc  [3]float32
5024                         ExpirationTime float32 // in seconds.
5025                         Size           float32
5026                         Collide        bool
5027
5028                         //mt:len32
5029                         Texture
5030
5031                         Vertical    bool
5032                         CollisionRm bool
5033                         AnimParams  TileAnim
5034                         Glow        uint8
5035                         AOCollision bool
5036                         NodeParam0  Content
5037                         NodeParam2  uint8
5038                         NodeTile    uint8
5039                 }))(obj)).Size
5040                 write32(w, math.Float32bits(x))
5041         }
5042         {
5043                 x := (*(*(struct {
5044                         Pos, Vel, Acc  [3]float32
5045                         ExpirationTime float32 // in seconds.
5046                         Size           float32
5047                         Collide        bool
5048
5049                         //mt:len32
5050                         Texture
5051
5052                         Vertical    bool
5053                         CollisionRm bool
5054                         AnimParams  TileAnim
5055                         Glow        uint8
5056                         AOCollision bool
5057                         NodeParam0  Content
5058                         NodeParam2  uint8
5059                         NodeTile    uint8
5060                 }))(obj)).Collide
5061                 if x {
5062                         write8(w, 1)
5063                 } else {
5064                         write8(w, 0)
5065                 }
5066         }
5067         if len(([]byte(*(*string)(&((*(*(struct {
5068                 Pos, Vel, Acc  [3]float32
5069                 ExpirationTime float32 // in seconds.
5070                 Size           float32
5071                 Collide        bool
5072
5073                 //mt:len32
5074                 Texture
5075
5076                 Vertical    bool
5077                 CollisionRm bool
5078                 AnimParams  TileAnim
5079                 Glow        uint8
5080                 AOCollision bool
5081                 NodeParam0  Content
5082                 NodeParam2  uint8
5083                 NodeTile    uint8
5084         }))(obj)).Texture))))) > math.MaxUint32 {
5085                 chk(ErrTooLong)
5086         }
5087         {
5088                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5089                         Pos, Vel, Acc  [3]float32
5090                         ExpirationTime float32 // in seconds.
5091                         Size           float32
5092                         Collide        bool
5093
5094                         //mt:len32
5095                         Texture
5096
5097                         Vertical    bool
5098                         CollisionRm bool
5099                         AnimParams  TileAnim
5100                         Glow        uint8
5101                         AOCollision bool
5102                         NodeParam0  Content
5103                         NodeParam2  uint8
5104                         NodeTile    uint8
5105                 }))(obj)).Texture))))))
5106                 write32(w, uint32(x))
5107         }
5108         {
5109                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5110                         Pos, Vel, Acc  [3]float32
5111                         ExpirationTime float32 // in seconds.
5112                         Size           float32
5113                         Collide        bool
5114
5115                         //mt:len32
5116                         Texture
5117
5118                         Vertical    bool
5119                         CollisionRm bool
5120                         AnimParams  TileAnim
5121                         Glow        uint8
5122                         AOCollision bool
5123                         NodeParam0  Content
5124                         NodeParam2  uint8
5125                         NodeTile    uint8
5126                 }))(obj)).Texture))))[:])
5127                 chk(err)
5128         }
5129         {
5130                 x := (*(*(struct {
5131                         Pos, Vel, Acc  [3]float32
5132                         ExpirationTime float32 // in seconds.
5133                         Size           float32
5134                         Collide        bool
5135
5136                         //mt:len32
5137                         Texture
5138
5139                         Vertical    bool
5140                         CollisionRm bool
5141                         AnimParams  TileAnim
5142                         Glow        uint8
5143                         AOCollision bool
5144                         NodeParam0  Content
5145                         NodeParam2  uint8
5146                         NodeTile    uint8
5147                 }))(obj)).Vertical
5148                 if x {
5149                         write8(w, 1)
5150                 } else {
5151                         write8(w, 0)
5152                 }
5153         }
5154         {
5155                 x := (*(*(struct {
5156                         Pos, Vel, Acc  [3]float32
5157                         ExpirationTime float32 // in seconds.
5158                         Size           float32
5159                         Collide        bool
5160
5161                         //mt:len32
5162                         Texture
5163
5164                         Vertical    bool
5165                         CollisionRm bool
5166                         AnimParams  TileAnim
5167                         Glow        uint8
5168                         AOCollision bool
5169                         NodeParam0  Content
5170                         NodeParam2  uint8
5171                         NodeTile    uint8
5172                 }))(obj)).CollisionRm
5173                 if x {
5174                         write8(w, 1)
5175                 } else {
5176                         write8(w, 0)
5177                 }
5178         }
5179         if err := pcall(func() {
5180                 ((*(*(struct {
5181                         Pos, Vel, Acc  [3]float32
5182                         ExpirationTime float32 // in seconds.
5183                         Size           float32
5184                         Collide        bool
5185
5186                         //mt:len32
5187                         Texture
5188
5189                         Vertical    bool
5190                         CollisionRm bool
5191                         AnimParams  TileAnim
5192                         Glow        uint8
5193                         AOCollision bool
5194                         NodeParam0  Content
5195                         NodeParam2  uint8
5196                         NodeTile    uint8
5197                 }))(obj)).AnimParams).serialize(w)
5198         }); err != nil {
5199                 if err == io.EOF {
5200                         chk(io.EOF)
5201                 }
5202                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5203         }
5204         {
5205                 x := (*(*(struct {
5206                         Pos, Vel, Acc  [3]float32
5207                         ExpirationTime float32 // in seconds.
5208                         Size           float32
5209                         Collide        bool
5210
5211                         //mt:len32
5212                         Texture
5213
5214                         Vertical    bool
5215                         CollisionRm bool
5216                         AnimParams  TileAnim
5217                         Glow        uint8
5218                         AOCollision bool
5219                         NodeParam0  Content
5220                         NodeParam2  uint8
5221                         NodeTile    uint8
5222                 }))(obj)).Glow
5223                 write8(w, uint8(x))
5224         }
5225         {
5226                 x := (*(*(struct {
5227                         Pos, Vel, Acc  [3]float32
5228                         ExpirationTime float32 // in seconds.
5229                         Size           float32
5230                         Collide        bool
5231
5232                         //mt:len32
5233                         Texture
5234
5235                         Vertical    bool
5236                         CollisionRm bool
5237                         AnimParams  TileAnim
5238                         Glow        uint8
5239                         AOCollision bool
5240                         NodeParam0  Content
5241                         NodeParam2  uint8
5242                         NodeTile    uint8
5243                 }))(obj)).AOCollision
5244                 if x {
5245                         write8(w, 1)
5246                 } else {
5247                         write8(w, 0)
5248                 }
5249         }
5250         if err := pcall(func() {
5251                 ((*(*(struct {
5252                         Pos, Vel, Acc  [3]float32
5253                         ExpirationTime float32 // in seconds.
5254                         Size           float32
5255                         Collide        bool
5256
5257                         //mt:len32
5258                         Texture
5259
5260                         Vertical    bool
5261                         CollisionRm bool
5262                         AnimParams  TileAnim
5263                         Glow        uint8
5264                         AOCollision bool
5265                         NodeParam0  Content
5266                         NodeParam2  uint8
5267                         NodeTile    uint8
5268                 }))(obj)).NodeParam0).serialize(w)
5269         }); err != nil {
5270                 if err == io.EOF {
5271                         chk(io.EOF)
5272                 }
5273                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5274         }
5275         {
5276                 x := (*(*(struct {
5277                         Pos, Vel, Acc  [3]float32
5278                         ExpirationTime float32 // in seconds.
5279                         Size           float32
5280                         Collide        bool
5281
5282                         //mt:len32
5283                         Texture
5284
5285                         Vertical    bool
5286                         CollisionRm bool
5287                         AnimParams  TileAnim
5288                         Glow        uint8
5289                         AOCollision bool
5290                         NodeParam0  Content
5291                         NodeParam2  uint8
5292                         NodeTile    uint8
5293                 }))(obj)).NodeParam2
5294                 write8(w, uint8(x))
5295         }
5296         {
5297                 x := (*(*(struct {
5298                         Pos, Vel, Acc  [3]float32
5299                         ExpirationTime float32 // in seconds.
5300                         Size           float32
5301                         Collide        bool
5302
5303                         //mt:len32
5304                         Texture
5305
5306                         Vertical    bool
5307                         CollisionRm bool
5308                         AnimParams  TileAnim
5309                         Glow        uint8
5310                         AOCollision bool
5311                         NodeParam0  Content
5312                         NodeParam2  uint8
5313                         NodeTile    uint8
5314                 }))(obj)).NodeTile
5315                 write8(w, uint8(x))
5316         }
5317 }
5318
5319 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5320         for local149 := range (*(*(struct {
5321                 Pos, Vel, Acc  [3]float32
5322                 ExpirationTime float32 // in seconds.
5323                 Size           float32
5324                 Collide        bool
5325
5326                 //mt:len32
5327                 Texture
5328
5329                 Vertical    bool
5330                 CollisionRm bool
5331                 AnimParams  TileAnim
5332                 Glow        uint8
5333                 AOCollision bool
5334                 NodeParam0  Content
5335                 NodeParam2  uint8
5336                 NodeTile    uint8
5337         }))(obj)).Pos {
5338                 {
5339                         p := &((*(*(struct {
5340                                 Pos, Vel, Acc  [3]float32
5341                                 ExpirationTime float32 // in seconds.
5342                                 Size           float32
5343                                 Collide        bool
5344
5345                                 //mt:len32
5346                                 Texture
5347
5348                                 Vertical    bool
5349                                 CollisionRm bool
5350                                 AnimParams  TileAnim
5351                                 Glow        uint8
5352                                 AOCollision bool
5353                                 NodeParam0  Content
5354                                 NodeParam2  uint8
5355                                 NodeTile    uint8
5356                         }))(obj)).Pos)[local149]
5357                         *p = math.Float32frombits(read32(r))
5358                 }
5359         }
5360         for local150 := range (*(*(struct {
5361                 Pos, Vel, Acc  [3]float32
5362                 ExpirationTime float32 // in seconds.
5363                 Size           float32
5364                 Collide        bool
5365
5366                 //mt:len32
5367                 Texture
5368
5369                 Vertical    bool
5370                 CollisionRm bool
5371                 AnimParams  TileAnim
5372                 Glow        uint8
5373                 AOCollision bool
5374                 NodeParam0  Content
5375                 NodeParam2  uint8
5376                 NodeTile    uint8
5377         }))(obj)).Vel {
5378                 {
5379                         p := &((*(*(struct {
5380                                 Pos, Vel, Acc  [3]float32
5381                                 ExpirationTime float32 // in seconds.
5382                                 Size           float32
5383                                 Collide        bool
5384
5385                                 //mt:len32
5386                                 Texture
5387
5388                                 Vertical    bool
5389                                 CollisionRm bool
5390                                 AnimParams  TileAnim
5391                                 Glow        uint8
5392                                 AOCollision bool
5393                                 NodeParam0  Content
5394                                 NodeParam2  uint8
5395                                 NodeTile    uint8
5396                         }))(obj)).Vel)[local150]
5397                         *p = math.Float32frombits(read32(r))
5398                 }
5399         }
5400         for local151 := range (*(*(struct {
5401                 Pos, Vel, Acc  [3]float32
5402                 ExpirationTime float32 // in seconds.
5403                 Size           float32
5404                 Collide        bool
5405
5406                 //mt:len32
5407                 Texture
5408
5409                 Vertical    bool
5410                 CollisionRm bool
5411                 AnimParams  TileAnim
5412                 Glow        uint8
5413                 AOCollision bool
5414                 NodeParam0  Content
5415                 NodeParam2  uint8
5416                 NodeTile    uint8
5417         }))(obj)).Acc {
5418                 {
5419                         p := &((*(*(struct {
5420                                 Pos, Vel, Acc  [3]float32
5421                                 ExpirationTime float32 // in seconds.
5422                                 Size           float32
5423                                 Collide        bool
5424
5425                                 //mt:len32
5426                                 Texture
5427
5428                                 Vertical    bool
5429                                 CollisionRm bool
5430                                 AnimParams  TileAnim
5431                                 Glow        uint8
5432                                 AOCollision bool
5433                                 NodeParam0  Content
5434                                 NodeParam2  uint8
5435                                 NodeTile    uint8
5436                         }))(obj)).Acc)[local151]
5437                         *p = math.Float32frombits(read32(r))
5438                 }
5439         }
5440         {
5441                 p := &(*(*(struct {
5442                         Pos, Vel, Acc  [3]float32
5443                         ExpirationTime float32 // in seconds.
5444                         Size           float32
5445                         Collide        bool
5446
5447                         //mt:len32
5448                         Texture
5449
5450                         Vertical    bool
5451                         CollisionRm bool
5452                         AnimParams  TileAnim
5453                         Glow        uint8
5454                         AOCollision bool
5455                         NodeParam0  Content
5456                         NodeParam2  uint8
5457                         NodeTile    uint8
5458                 }))(obj)).ExpirationTime
5459                 *p = math.Float32frombits(read32(r))
5460         }
5461         {
5462                 p := &(*(*(struct {
5463                         Pos, Vel, Acc  [3]float32
5464                         ExpirationTime float32 // in seconds.
5465                         Size           float32
5466                         Collide        bool
5467
5468                         //mt:len32
5469                         Texture
5470
5471                         Vertical    bool
5472                         CollisionRm bool
5473                         AnimParams  TileAnim
5474                         Glow        uint8
5475                         AOCollision bool
5476                         NodeParam0  Content
5477                         NodeParam2  uint8
5478                         NodeTile    uint8
5479                 }))(obj)).Size
5480                 *p = math.Float32frombits(read32(r))
5481         }
5482         {
5483                 p := &(*(*(struct {
5484                         Pos, Vel, Acc  [3]float32
5485                         ExpirationTime float32 // in seconds.
5486                         Size           float32
5487                         Collide        bool
5488
5489                         //mt:len32
5490                         Texture
5491
5492                         Vertical    bool
5493                         CollisionRm bool
5494                         AnimParams  TileAnim
5495                         Glow        uint8
5496                         AOCollision bool
5497                         NodeParam0  Content
5498                         NodeParam2  uint8
5499                         NodeTile    uint8
5500                 }))(obj)).Collide
5501                 switch n := read8(r); n {
5502                 case 0:
5503                         *p = false
5504                 case 1:
5505                         *p = true
5506                 default:
5507                         chk(fmt.Errorf("invalid bool: %d", n))
5508                 }
5509         }
5510         var local152 []uint8
5511         var local153 uint32
5512         {
5513                 p := &local153
5514                 *p = read32(r)
5515         }
5516         (local152) = make([]uint8, local153)
5517         {
5518                 _, err := io.ReadFull(r, (local152)[:])
5519                 chk(err)
5520         }
5521         (*(*string)(&((*(*(struct {
5522                 Pos, Vel, Acc  [3]float32
5523                 ExpirationTime float32 // in seconds.
5524                 Size           float32
5525                 Collide        bool
5526
5527                 //mt:len32
5528                 Texture
5529
5530                 Vertical    bool
5531                 CollisionRm bool
5532                 AnimParams  TileAnim
5533                 Glow        uint8
5534                 AOCollision bool
5535                 NodeParam0  Content
5536                 NodeParam2  uint8
5537                 NodeTile    uint8
5538         }))(obj)).Texture))) = string(local152)
5539         {
5540                 p := &(*(*(struct {
5541                         Pos, Vel, Acc  [3]float32
5542                         ExpirationTime float32 // in seconds.
5543                         Size           float32
5544                         Collide        bool
5545
5546                         //mt:len32
5547                         Texture
5548
5549                         Vertical    bool
5550                         CollisionRm bool
5551                         AnimParams  TileAnim
5552                         Glow        uint8
5553                         AOCollision bool
5554                         NodeParam0  Content
5555                         NodeParam2  uint8
5556                         NodeTile    uint8
5557                 }))(obj)).Vertical
5558                 switch n := read8(r); n {
5559                 case 0:
5560                         *p = false
5561                 case 1:
5562                         *p = true
5563                 default:
5564                         chk(fmt.Errorf("invalid bool: %d", n))
5565                 }
5566         }
5567         {
5568                 p := &(*(*(struct {
5569                         Pos, Vel, Acc  [3]float32
5570                         ExpirationTime float32 // in seconds.
5571                         Size           float32
5572                         Collide        bool
5573
5574                         //mt:len32
5575                         Texture
5576
5577                         Vertical    bool
5578                         CollisionRm bool
5579                         AnimParams  TileAnim
5580                         Glow        uint8
5581                         AOCollision bool
5582                         NodeParam0  Content
5583                         NodeParam2  uint8
5584                         NodeTile    uint8
5585                 }))(obj)).CollisionRm
5586                 switch n := read8(r); n {
5587                 case 0:
5588                         *p = false
5589                 case 1:
5590                         *p = true
5591                 default:
5592                         chk(fmt.Errorf("invalid bool: %d", n))
5593                 }
5594         }
5595         if err := pcall(func() {
5596                 ((*(*(struct {
5597                         Pos, Vel, Acc  [3]float32
5598                         ExpirationTime float32 // in seconds.
5599                         Size           float32
5600                         Collide        bool
5601
5602                         //mt:len32
5603                         Texture
5604
5605                         Vertical    bool
5606                         CollisionRm bool
5607                         AnimParams  TileAnim
5608                         Glow        uint8
5609                         AOCollision bool
5610                         NodeParam0  Content
5611                         NodeParam2  uint8
5612                         NodeTile    uint8
5613                 }))(obj)).AnimParams).deserialize(r)
5614         }); err != nil {
5615                 if err == io.EOF {
5616                         chk(io.EOF)
5617                 }
5618                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5619         }
5620         {
5621                 p := &(*(*(struct {
5622                         Pos, Vel, Acc  [3]float32
5623                         ExpirationTime float32 // in seconds.
5624                         Size           float32
5625                         Collide        bool
5626
5627                         //mt:len32
5628                         Texture
5629
5630                         Vertical    bool
5631                         CollisionRm bool
5632                         AnimParams  TileAnim
5633                         Glow        uint8
5634                         AOCollision bool
5635                         NodeParam0  Content
5636                         NodeParam2  uint8
5637                         NodeTile    uint8
5638                 }))(obj)).Glow
5639                 *p = read8(r)
5640         }
5641         {
5642                 p := &(*(*(struct {
5643                         Pos, Vel, Acc  [3]float32
5644                         ExpirationTime float32 // in seconds.
5645                         Size           float32
5646                         Collide        bool
5647
5648                         //mt:len32
5649                         Texture
5650
5651                         Vertical    bool
5652                         CollisionRm bool
5653                         AnimParams  TileAnim
5654                         Glow        uint8
5655                         AOCollision bool
5656                         NodeParam0  Content
5657                         NodeParam2  uint8
5658                         NodeTile    uint8
5659                 }))(obj)).AOCollision
5660                 switch n := read8(r); n {
5661                 case 0:
5662                         *p = false
5663                 case 1:
5664                         *p = true
5665                 default:
5666                         chk(fmt.Errorf("invalid bool: %d", n))
5667                 }
5668         }
5669         if err := pcall(func() {
5670                 ((*(*(struct {
5671                         Pos, Vel, Acc  [3]float32
5672                         ExpirationTime float32 // in seconds.
5673                         Size           float32
5674                         Collide        bool
5675
5676                         //mt:len32
5677                         Texture
5678
5679                         Vertical    bool
5680                         CollisionRm bool
5681                         AnimParams  TileAnim
5682                         Glow        uint8
5683                         AOCollision bool
5684                         NodeParam0  Content
5685                         NodeParam2  uint8
5686                         NodeTile    uint8
5687                 }))(obj)).NodeParam0).deserialize(r)
5688         }); err != nil {
5689                 if err == io.EOF {
5690                         chk(io.EOF)
5691                 }
5692                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5693         }
5694         {
5695                 p := &(*(*(struct {
5696                         Pos, Vel, Acc  [3]float32
5697                         ExpirationTime float32 // in seconds.
5698                         Size           float32
5699                         Collide        bool
5700
5701                         //mt:len32
5702                         Texture
5703
5704                         Vertical    bool
5705                         CollisionRm bool
5706                         AnimParams  TileAnim
5707                         Glow        uint8
5708                         AOCollision bool
5709                         NodeParam0  Content
5710                         NodeParam2  uint8
5711                         NodeTile    uint8
5712                 }))(obj)).NodeParam2
5713                 *p = read8(r)
5714         }
5715         {
5716                 p := &(*(*(struct {
5717                         Pos, Vel, Acc  [3]float32
5718                         ExpirationTime float32 // in seconds.
5719                         Size           float32
5720                         Collide        bool
5721
5722                         //mt:len32
5723                         Texture
5724
5725                         Vertical    bool
5726                         CollisionRm bool
5727                         AnimParams  TileAnim
5728                         Glow        uint8
5729                         AOCollision bool
5730                         NodeParam0  Content
5731                         NodeParam2  uint8
5732                         NodeTile    uint8
5733                 }))(obj)).NodeTile
5734                 *p = read8(r)
5735         }
5736 }
5737
5738 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
5739         {
5740                 x := (*(*(struct {
5741                         Amount         uint16
5742                         Duration       float32
5743                         Pos, Vel, Acc  [2][3]float32
5744                         ExpirationTime [2]float32 // in seconds.
5745                         Size           [2]float32
5746                         Collide        bool
5747
5748                         //mt:len32
5749                         Texture
5750
5751                         ID           ParticleSpawnerID
5752                         Vertical     bool
5753                         CollisionRm  bool
5754                         AttachedAOID AOID
5755                         AnimParams   TileAnim
5756                         Glow         uint8
5757                         AOCollision  bool
5758                         NodeParam0   Content
5759                         NodeParam2   uint8
5760                         NodeTile     uint8
5761                 }))(obj)).Amount
5762                 write16(w, uint16(x))
5763         }
5764         {
5765                 x := (*(*(struct {
5766                         Amount         uint16
5767                         Duration       float32
5768                         Pos, Vel, Acc  [2][3]float32
5769                         ExpirationTime [2]float32 // in seconds.
5770                         Size           [2]float32
5771                         Collide        bool
5772
5773                         //mt:len32
5774                         Texture
5775
5776                         ID           ParticleSpawnerID
5777                         Vertical     bool
5778                         CollisionRm  bool
5779                         AttachedAOID AOID
5780                         AnimParams   TileAnim
5781                         Glow         uint8
5782                         AOCollision  bool
5783                         NodeParam0   Content
5784                         NodeParam2   uint8
5785                         NodeTile     uint8
5786                 }))(obj)).Duration
5787                 write32(w, math.Float32bits(x))
5788         }
5789         for local154 := range (*(*(struct {
5790                 Amount         uint16
5791                 Duration       float32
5792                 Pos, Vel, Acc  [2][3]float32
5793                 ExpirationTime [2]float32 // in seconds.
5794                 Size           [2]float32
5795                 Collide        bool
5796
5797                 //mt:len32
5798                 Texture
5799
5800                 ID           ParticleSpawnerID
5801                 Vertical     bool
5802                 CollisionRm  bool
5803                 AttachedAOID AOID
5804                 AnimParams   TileAnim
5805                 Glow         uint8
5806                 AOCollision  bool
5807                 NodeParam0   Content
5808                 NodeParam2   uint8
5809                 NodeTile     uint8
5810         }))(obj)).Pos {
5811                 for local155 := range ((*(*(struct {
5812                         Amount         uint16
5813                         Duration       float32
5814                         Pos, Vel, Acc  [2][3]float32
5815                         ExpirationTime [2]float32 // in seconds.
5816                         Size           [2]float32
5817                         Collide        bool
5818
5819                         //mt:len32
5820                         Texture
5821
5822                         ID           ParticleSpawnerID
5823                         Vertical     bool
5824                         CollisionRm  bool
5825                         AttachedAOID AOID
5826                         AnimParams   TileAnim
5827                         Glow         uint8
5828                         AOCollision  bool
5829                         NodeParam0   Content
5830                         NodeParam2   uint8
5831                         NodeTile     uint8
5832                 }))(obj)).Pos)[local154] {
5833                         {
5834                                 x := (((*(*(struct {
5835                                         Amount         uint16
5836                                         Duration       float32
5837                                         Pos, Vel, Acc  [2][3]float32
5838                                         ExpirationTime [2]float32 // in seconds.
5839                                         Size           [2]float32
5840                                         Collide        bool
5841
5842                                         //mt:len32
5843                                         Texture
5844
5845                                         ID           ParticleSpawnerID
5846                                         Vertical     bool
5847                                         CollisionRm  bool
5848                                         AttachedAOID AOID
5849                                         AnimParams   TileAnim
5850                                         Glow         uint8
5851                                         AOCollision  bool
5852                                         NodeParam0   Content
5853                                         NodeParam2   uint8
5854                                         NodeTile     uint8
5855                                 }))(obj)).Pos)[local154])[local155]
5856                                 write32(w, math.Float32bits(x))
5857                         }
5858                 }
5859         }
5860         for local156 := range (*(*(struct {
5861                 Amount         uint16
5862                 Duration       float32
5863                 Pos, Vel, Acc  [2][3]float32
5864                 ExpirationTime [2]float32 // in seconds.
5865                 Size           [2]float32
5866                 Collide        bool
5867
5868                 //mt:len32
5869                 Texture
5870
5871                 ID           ParticleSpawnerID
5872                 Vertical     bool
5873                 CollisionRm  bool
5874                 AttachedAOID AOID
5875                 AnimParams   TileAnim
5876                 Glow         uint8
5877                 AOCollision  bool
5878                 NodeParam0   Content
5879                 NodeParam2   uint8
5880                 NodeTile     uint8
5881         }))(obj)).Vel {
5882                 for local157 := range ((*(*(struct {
5883                         Amount         uint16
5884                         Duration       float32
5885                         Pos, Vel, Acc  [2][3]float32
5886                         ExpirationTime [2]float32 // in seconds.
5887                         Size           [2]float32
5888                         Collide        bool
5889
5890                         //mt:len32
5891                         Texture
5892
5893                         ID           ParticleSpawnerID
5894                         Vertical     bool
5895                         CollisionRm  bool
5896                         AttachedAOID AOID
5897                         AnimParams   TileAnim
5898                         Glow         uint8
5899                         AOCollision  bool
5900                         NodeParam0   Content
5901                         NodeParam2   uint8
5902                         NodeTile     uint8
5903                 }))(obj)).Vel)[local156] {
5904                         {
5905                                 x := (((*(*(struct {
5906                                         Amount         uint16
5907                                         Duration       float32
5908                                         Pos, Vel, Acc  [2][3]float32
5909                                         ExpirationTime [2]float32 // in seconds.
5910                                         Size           [2]float32
5911                                         Collide        bool
5912
5913                                         //mt:len32
5914                                         Texture
5915
5916                                         ID           ParticleSpawnerID
5917                                         Vertical     bool
5918                                         CollisionRm  bool
5919                                         AttachedAOID AOID
5920                                         AnimParams   TileAnim
5921                                         Glow         uint8
5922                                         AOCollision  bool
5923                                         NodeParam0   Content
5924                                         NodeParam2   uint8
5925                                         NodeTile     uint8
5926                                 }))(obj)).Vel)[local156])[local157]
5927                                 write32(w, math.Float32bits(x))
5928                         }
5929                 }
5930         }
5931         for local158 := range (*(*(struct {
5932                 Amount         uint16
5933                 Duration       float32
5934                 Pos, Vel, Acc  [2][3]float32
5935                 ExpirationTime [2]float32 // in seconds.
5936                 Size           [2]float32
5937                 Collide        bool
5938
5939                 //mt:len32
5940                 Texture
5941
5942                 ID           ParticleSpawnerID
5943                 Vertical     bool
5944                 CollisionRm  bool
5945                 AttachedAOID AOID
5946                 AnimParams   TileAnim
5947                 Glow         uint8
5948                 AOCollision  bool
5949                 NodeParam0   Content
5950                 NodeParam2   uint8
5951                 NodeTile     uint8
5952         }))(obj)).Acc {
5953                 for local159 := range ((*(*(struct {
5954                         Amount         uint16
5955                         Duration       float32
5956                         Pos, Vel, Acc  [2][3]float32
5957                         ExpirationTime [2]float32 // in seconds.
5958                         Size           [2]float32
5959                         Collide        bool
5960
5961                         //mt:len32
5962                         Texture
5963
5964                         ID           ParticleSpawnerID
5965                         Vertical     bool
5966                         CollisionRm  bool
5967                         AttachedAOID AOID
5968                         AnimParams   TileAnim
5969                         Glow         uint8
5970                         AOCollision  bool
5971                         NodeParam0   Content
5972                         NodeParam2   uint8
5973                         NodeTile     uint8
5974                 }))(obj)).Acc)[local158] {
5975                         {
5976                                 x := (((*(*(struct {
5977                                         Amount         uint16
5978                                         Duration       float32
5979                                         Pos, Vel, Acc  [2][3]float32
5980                                         ExpirationTime [2]float32 // in seconds.
5981                                         Size           [2]float32
5982                                         Collide        bool
5983
5984                                         //mt:len32
5985                                         Texture
5986
5987                                         ID           ParticleSpawnerID
5988                                         Vertical     bool
5989                                         CollisionRm  bool
5990                                         AttachedAOID AOID
5991                                         AnimParams   TileAnim
5992                                         Glow         uint8
5993                                         AOCollision  bool
5994                                         NodeParam0   Content
5995                                         NodeParam2   uint8
5996                                         NodeTile     uint8
5997                                 }))(obj)).Acc)[local158])[local159]
5998                                 write32(w, math.Float32bits(x))
5999                         }
6000                 }
6001         }
6002         for local160 := range (*(*(struct {
6003                 Amount         uint16
6004                 Duration       float32
6005                 Pos, Vel, Acc  [2][3]float32
6006                 ExpirationTime [2]float32 // in seconds.
6007                 Size           [2]float32
6008                 Collide        bool
6009
6010                 //mt:len32
6011                 Texture
6012
6013                 ID           ParticleSpawnerID
6014                 Vertical     bool
6015                 CollisionRm  bool
6016                 AttachedAOID AOID
6017                 AnimParams   TileAnim
6018                 Glow         uint8
6019                 AOCollision  bool
6020                 NodeParam0   Content
6021                 NodeParam2   uint8
6022                 NodeTile     uint8
6023         }))(obj)).ExpirationTime {
6024                 {
6025                         x := ((*(*(struct {
6026                                 Amount         uint16
6027                                 Duration       float32
6028                                 Pos, Vel, Acc  [2][3]float32
6029                                 ExpirationTime [2]float32 // in seconds.
6030                                 Size           [2]float32
6031                                 Collide        bool
6032
6033                                 //mt:len32
6034                                 Texture
6035
6036                                 ID           ParticleSpawnerID
6037                                 Vertical     bool
6038                                 CollisionRm  bool
6039                                 AttachedAOID AOID
6040                                 AnimParams   TileAnim
6041                                 Glow         uint8
6042                                 AOCollision  bool
6043                                 NodeParam0   Content
6044                                 NodeParam2   uint8
6045                                 NodeTile     uint8
6046                         }))(obj)).ExpirationTime)[local160]
6047                         write32(w, math.Float32bits(x))
6048                 }
6049         }
6050         for local161 := range (*(*(struct {
6051                 Amount         uint16
6052                 Duration       float32
6053                 Pos, Vel, Acc  [2][3]float32
6054                 ExpirationTime [2]float32 // in seconds.
6055                 Size           [2]float32
6056                 Collide        bool
6057
6058                 //mt:len32
6059                 Texture
6060
6061                 ID           ParticleSpawnerID
6062                 Vertical     bool
6063                 CollisionRm  bool
6064                 AttachedAOID AOID
6065                 AnimParams   TileAnim
6066                 Glow         uint8
6067                 AOCollision  bool
6068                 NodeParam0   Content
6069                 NodeParam2   uint8
6070                 NodeTile     uint8
6071         }))(obj)).Size {
6072                 {
6073                         x := ((*(*(struct {
6074                                 Amount         uint16
6075                                 Duration       float32
6076                                 Pos, Vel, Acc  [2][3]float32
6077                                 ExpirationTime [2]float32 // in seconds.
6078                                 Size           [2]float32
6079                                 Collide        bool
6080
6081                                 //mt:len32
6082                                 Texture
6083
6084                                 ID           ParticleSpawnerID
6085                                 Vertical     bool
6086                                 CollisionRm  bool
6087                                 AttachedAOID AOID
6088                                 AnimParams   TileAnim
6089                                 Glow         uint8
6090                                 AOCollision  bool
6091                                 NodeParam0   Content
6092                                 NodeParam2   uint8
6093                                 NodeTile     uint8
6094                         }))(obj)).Size)[local161]
6095                         write32(w, math.Float32bits(x))
6096                 }
6097         }
6098         {
6099                 x := (*(*(struct {
6100                         Amount         uint16
6101                         Duration       float32
6102                         Pos, Vel, Acc  [2][3]float32
6103                         ExpirationTime [2]float32 // in seconds.
6104                         Size           [2]float32
6105                         Collide        bool
6106
6107                         //mt:len32
6108                         Texture
6109
6110                         ID           ParticleSpawnerID
6111                         Vertical     bool
6112                         CollisionRm  bool
6113                         AttachedAOID AOID
6114                         AnimParams   TileAnim
6115                         Glow         uint8
6116                         AOCollision  bool
6117                         NodeParam0   Content
6118                         NodeParam2   uint8
6119                         NodeTile     uint8
6120                 }))(obj)).Collide
6121                 if x {
6122                         write8(w, 1)
6123                 } else {
6124                         write8(w, 0)
6125                 }
6126         }
6127         if len(([]byte(*(*string)(&((*(*(struct {
6128                 Amount         uint16
6129                 Duration       float32
6130                 Pos, Vel, Acc  [2][3]float32
6131                 ExpirationTime [2]float32 // in seconds.
6132                 Size           [2]float32
6133                 Collide        bool
6134
6135                 //mt:len32
6136                 Texture
6137
6138                 ID           ParticleSpawnerID
6139                 Vertical     bool
6140                 CollisionRm  bool
6141                 AttachedAOID AOID
6142                 AnimParams   TileAnim
6143                 Glow         uint8
6144                 AOCollision  bool
6145                 NodeParam0   Content
6146                 NodeParam2   uint8
6147                 NodeTile     uint8
6148         }))(obj)).Texture))))) > math.MaxUint32 {
6149                 chk(ErrTooLong)
6150         }
6151         {
6152                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6153                         Amount         uint16
6154                         Duration       float32
6155                         Pos, Vel, Acc  [2][3]float32
6156                         ExpirationTime [2]float32 // in seconds.
6157                         Size           [2]float32
6158                         Collide        bool
6159
6160                         //mt:len32
6161                         Texture
6162
6163                         ID           ParticleSpawnerID
6164                         Vertical     bool
6165                         CollisionRm  bool
6166                         AttachedAOID AOID
6167                         AnimParams   TileAnim
6168                         Glow         uint8
6169                         AOCollision  bool
6170                         NodeParam0   Content
6171                         NodeParam2   uint8
6172                         NodeTile     uint8
6173                 }))(obj)).Texture))))))
6174                 write32(w, uint32(x))
6175         }
6176         {
6177                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6178                         Amount         uint16
6179                         Duration       float32
6180                         Pos, Vel, Acc  [2][3]float32
6181                         ExpirationTime [2]float32 // in seconds.
6182                         Size           [2]float32
6183                         Collide        bool
6184
6185                         //mt:len32
6186                         Texture
6187
6188                         ID           ParticleSpawnerID
6189                         Vertical     bool
6190                         CollisionRm  bool
6191                         AttachedAOID AOID
6192                         AnimParams   TileAnim
6193                         Glow         uint8
6194                         AOCollision  bool
6195                         NodeParam0   Content
6196                         NodeParam2   uint8
6197                         NodeTile     uint8
6198                 }))(obj)).Texture))))[:])
6199                 chk(err)
6200         }
6201         if err := pcall(func() {
6202                 ((*(*(struct {
6203                         Amount         uint16
6204                         Duration       float32
6205                         Pos, Vel, Acc  [2][3]float32
6206                         ExpirationTime [2]float32 // in seconds.
6207                         Size           [2]float32
6208                         Collide        bool
6209
6210                         //mt:len32
6211                         Texture
6212
6213                         ID           ParticleSpawnerID
6214                         Vertical     bool
6215                         CollisionRm  bool
6216                         AttachedAOID AOID
6217                         AnimParams   TileAnim
6218                         Glow         uint8
6219                         AOCollision  bool
6220                         NodeParam0   Content
6221                         NodeParam2   uint8
6222                         NodeTile     uint8
6223                 }))(obj)).ID).serialize(w)
6224         }); err != nil {
6225                 if err == io.EOF {
6226                         chk(io.EOF)
6227                 }
6228                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6229         }
6230         {
6231                 x := (*(*(struct {
6232                         Amount         uint16
6233                         Duration       float32
6234                         Pos, Vel, Acc  [2][3]float32
6235                         ExpirationTime [2]float32 // in seconds.
6236                         Size           [2]float32
6237                         Collide        bool
6238
6239                         //mt:len32
6240                         Texture
6241
6242                         ID           ParticleSpawnerID
6243                         Vertical     bool
6244                         CollisionRm  bool
6245                         AttachedAOID AOID
6246                         AnimParams   TileAnim
6247                         Glow         uint8
6248                         AOCollision  bool
6249                         NodeParam0   Content
6250                         NodeParam2   uint8
6251                         NodeTile     uint8
6252                 }))(obj)).Vertical
6253                 if x {
6254                         write8(w, 1)
6255                 } else {
6256                         write8(w, 0)
6257                 }
6258         }
6259         {
6260                 x := (*(*(struct {
6261                         Amount         uint16
6262                         Duration       float32
6263                         Pos, Vel, Acc  [2][3]float32
6264                         ExpirationTime [2]float32 // in seconds.
6265                         Size           [2]float32
6266                         Collide        bool
6267
6268                         //mt:len32
6269                         Texture
6270
6271                         ID           ParticleSpawnerID
6272                         Vertical     bool
6273                         CollisionRm  bool
6274                         AttachedAOID AOID
6275                         AnimParams   TileAnim
6276                         Glow         uint8
6277                         AOCollision  bool
6278                         NodeParam0   Content
6279                         NodeParam2   uint8
6280                         NodeTile     uint8
6281                 }))(obj)).CollisionRm
6282                 if x {
6283                         write8(w, 1)
6284                 } else {
6285                         write8(w, 0)
6286                 }
6287         }
6288         if err := pcall(func() {
6289                 ((*(*(struct {
6290                         Amount         uint16
6291                         Duration       float32
6292                         Pos, Vel, Acc  [2][3]float32
6293                         ExpirationTime [2]float32 // in seconds.
6294                         Size           [2]float32
6295                         Collide        bool
6296
6297                         //mt:len32
6298                         Texture
6299
6300                         ID           ParticleSpawnerID
6301                         Vertical     bool
6302                         CollisionRm  bool
6303                         AttachedAOID AOID
6304                         AnimParams   TileAnim
6305                         Glow         uint8
6306                         AOCollision  bool
6307                         NodeParam0   Content
6308                         NodeParam2   uint8
6309                         NodeTile     uint8
6310                 }))(obj)).AttachedAOID).serialize(w)
6311         }); err != nil {
6312                 if err == io.EOF {
6313                         chk(io.EOF)
6314                 }
6315                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
6316         }
6317         if err := pcall(func() {
6318                 ((*(*(struct {
6319                         Amount         uint16
6320                         Duration       float32
6321                         Pos, Vel, Acc  [2][3]float32
6322                         ExpirationTime [2]float32 // in seconds.
6323                         Size           [2]float32
6324                         Collide        bool
6325
6326                         //mt:len32
6327                         Texture
6328
6329                         ID           ParticleSpawnerID
6330                         Vertical     bool
6331                         CollisionRm  bool
6332                         AttachedAOID AOID
6333                         AnimParams   TileAnim
6334                         Glow         uint8
6335                         AOCollision  bool
6336                         NodeParam0   Content
6337                         NodeParam2   uint8
6338                         NodeTile     uint8
6339                 }))(obj)).AnimParams).serialize(w)
6340         }); err != nil {
6341                 if err == io.EOF {
6342                         chk(io.EOF)
6343                 }
6344                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
6345         }
6346         {
6347                 x := (*(*(struct {
6348                         Amount         uint16
6349                         Duration       float32
6350                         Pos, Vel, Acc  [2][3]float32
6351                         ExpirationTime [2]float32 // in seconds.
6352                         Size           [2]float32
6353                         Collide        bool
6354
6355                         //mt:len32
6356                         Texture
6357
6358                         ID           ParticleSpawnerID
6359                         Vertical     bool
6360                         CollisionRm  bool
6361                         AttachedAOID AOID
6362                         AnimParams   TileAnim
6363                         Glow         uint8
6364                         AOCollision  bool
6365                         NodeParam0   Content
6366                         NodeParam2   uint8
6367                         NodeTile     uint8
6368                 }))(obj)).Glow
6369                 write8(w, uint8(x))
6370         }
6371         {
6372                 x := (*(*(struct {
6373                         Amount         uint16
6374                         Duration       float32
6375                         Pos, Vel, Acc  [2][3]float32
6376                         ExpirationTime [2]float32 // in seconds.
6377                         Size           [2]float32
6378                         Collide        bool
6379
6380                         //mt:len32
6381                         Texture
6382
6383                         ID           ParticleSpawnerID
6384                         Vertical     bool
6385                         CollisionRm  bool
6386                         AttachedAOID AOID
6387                         AnimParams   TileAnim
6388                         Glow         uint8
6389                         AOCollision  bool
6390                         NodeParam0   Content
6391                         NodeParam2   uint8
6392                         NodeTile     uint8
6393                 }))(obj)).AOCollision
6394                 if x {
6395                         write8(w, 1)
6396                 } else {
6397                         write8(w, 0)
6398                 }
6399         }
6400         if err := pcall(func() {
6401                 ((*(*(struct {
6402                         Amount         uint16
6403                         Duration       float32
6404                         Pos, Vel, Acc  [2][3]float32
6405                         ExpirationTime [2]float32 // in seconds.
6406                         Size           [2]float32
6407                         Collide        bool
6408
6409                         //mt:len32
6410                         Texture
6411
6412                         ID           ParticleSpawnerID
6413                         Vertical     bool
6414                         CollisionRm  bool
6415                         AttachedAOID AOID
6416                         AnimParams   TileAnim
6417                         Glow         uint8
6418                         AOCollision  bool
6419                         NodeParam0   Content
6420                         NodeParam2   uint8
6421                         NodeTile     uint8
6422                 }))(obj)).NodeParam0).serialize(w)
6423         }); err != nil {
6424                 if err == io.EOF {
6425                         chk(io.EOF)
6426                 }
6427                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
6428         }
6429         {
6430                 x := (*(*(struct {
6431                         Amount         uint16
6432                         Duration       float32
6433                         Pos, Vel, Acc  [2][3]float32
6434                         ExpirationTime [2]float32 // in seconds.
6435                         Size           [2]float32
6436                         Collide        bool
6437
6438                         //mt:len32
6439                         Texture
6440
6441                         ID           ParticleSpawnerID
6442                         Vertical     bool
6443                         CollisionRm  bool
6444                         AttachedAOID AOID
6445                         AnimParams   TileAnim
6446                         Glow         uint8
6447                         AOCollision  bool
6448                         NodeParam0   Content
6449                         NodeParam2   uint8
6450                         NodeTile     uint8
6451                 }))(obj)).NodeParam2
6452                 write8(w, uint8(x))
6453         }
6454         {
6455                 x := (*(*(struct {
6456                         Amount         uint16
6457                         Duration       float32
6458                         Pos, Vel, Acc  [2][3]float32
6459                         ExpirationTime [2]float32 // in seconds.
6460                         Size           [2]float32
6461                         Collide        bool
6462
6463                         //mt:len32
6464                         Texture
6465
6466                         ID           ParticleSpawnerID
6467                         Vertical     bool
6468                         CollisionRm  bool
6469                         AttachedAOID AOID
6470                         AnimParams   TileAnim
6471                         Glow         uint8
6472                         AOCollision  bool
6473                         NodeParam0   Content
6474                         NodeParam2   uint8
6475                         NodeTile     uint8
6476                 }))(obj)).NodeTile
6477                 write8(w, uint8(x))
6478         }
6479 }
6480
6481 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6482         {
6483                 p := &(*(*(struct {
6484                         Amount         uint16
6485                         Duration       float32
6486                         Pos, Vel, Acc  [2][3]float32
6487                         ExpirationTime [2]float32 // in seconds.
6488                         Size           [2]float32
6489                         Collide        bool
6490
6491                         //mt:len32
6492                         Texture
6493
6494                         ID           ParticleSpawnerID
6495                         Vertical     bool
6496                         CollisionRm  bool
6497                         AttachedAOID AOID
6498                         AnimParams   TileAnim
6499                         Glow         uint8
6500                         AOCollision  bool
6501                         NodeParam0   Content
6502                         NodeParam2   uint8
6503                         NodeTile     uint8
6504                 }))(obj)).Amount
6505                 *p = read16(r)
6506         }
6507         {
6508                 p := &(*(*(struct {
6509                         Amount         uint16
6510                         Duration       float32
6511                         Pos, Vel, Acc  [2][3]float32
6512                         ExpirationTime [2]float32 // in seconds.
6513                         Size           [2]float32
6514                         Collide        bool
6515
6516                         //mt:len32
6517                         Texture
6518
6519                         ID           ParticleSpawnerID
6520                         Vertical     bool
6521                         CollisionRm  bool
6522                         AttachedAOID AOID
6523                         AnimParams   TileAnim
6524                         Glow         uint8
6525                         AOCollision  bool
6526                         NodeParam0   Content
6527                         NodeParam2   uint8
6528                         NodeTile     uint8
6529                 }))(obj)).Duration
6530                 *p = math.Float32frombits(read32(r))
6531         }
6532         for local162 := range (*(*(struct {
6533                 Amount         uint16
6534                 Duration       float32
6535                 Pos, Vel, Acc  [2][3]float32
6536                 ExpirationTime [2]float32 // in seconds.
6537                 Size           [2]float32
6538                 Collide        bool
6539
6540                 //mt:len32
6541                 Texture
6542
6543                 ID           ParticleSpawnerID
6544                 Vertical     bool
6545                 CollisionRm  bool
6546                 AttachedAOID AOID
6547                 AnimParams   TileAnim
6548                 Glow         uint8
6549                 AOCollision  bool
6550                 NodeParam0   Content
6551                 NodeParam2   uint8
6552                 NodeTile     uint8
6553         }))(obj)).Pos {
6554                 for local163 := range ((*(*(struct {
6555                         Amount         uint16
6556                         Duration       float32
6557                         Pos, Vel, Acc  [2][3]float32
6558                         ExpirationTime [2]float32 // in seconds.
6559                         Size           [2]float32
6560                         Collide        bool
6561
6562                         //mt:len32
6563                         Texture
6564
6565                         ID           ParticleSpawnerID
6566                         Vertical     bool
6567                         CollisionRm  bool
6568                         AttachedAOID AOID
6569                         AnimParams   TileAnim
6570                         Glow         uint8
6571                         AOCollision  bool
6572                         NodeParam0   Content
6573                         NodeParam2   uint8
6574                         NodeTile     uint8
6575                 }))(obj)).Pos)[local162] {
6576                         {
6577                                 p := &(((*(*(struct {
6578                                         Amount         uint16
6579                                         Duration       float32
6580                                         Pos, Vel, Acc  [2][3]float32
6581                                         ExpirationTime [2]float32 // in seconds.
6582                                         Size           [2]float32
6583                                         Collide        bool
6584
6585                                         //mt:len32
6586                                         Texture
6587
6588                                         ID           ParticleSpawnerID
6589                                         Vertical     bool
6590                                         CollisionRm  bool
6591                                         AttachedAOID AOID
6592                                         AnimParams   TileAnim
6593                                         Glow         uint8
6594                                         AOCollision  bool
6595                                         NodeParam0   Content
6596                                         NodeParam2   uint8
6597                                         NodeTile     uint8
6598                                 }))(obj)).Pos)[local162])[local163]
6599                                 *p = math.Float32frombits(read32(r))
6600                         }
6601                 }
6602         }
6603         for local164 := range (*(*(struct {
6604                 Amount         uint16
6605                 Duration       float32
6606                 Pos, Vel, Acc  [2][3]float32
6607                 ExpirationTime [2]float32 // in seconds.
6608                 Size           [2]float32
6609                 Collide        bool
6610
6611                 //mt:len32
6612                 Texture
6613
6614                 ID           ParticleSpawnerID
6615                 Vertical     bool
6616                 CollisionRm  bool
6617                 AttachedAOID AOID
6618                 AnimParams   TileAnim
6619                 Glow         uint8
6620                 AOCollision  bool
6621                 NodeParam0   Content
6622                 NodeParam2   uint8
6623                 NodeTile     uint8
6624         }))(obj)).Vel {
6625                 for local165 := range ((*(*(struct {
6626                         Amount         uint16
6627                         Duration       float32
6628                         Pos, Vel, Acc  [2][3]float32
6629                         ExpirationTime [2]float32 // in seconds.
6630                         Size           [2]float32
6631                         Collide        bool
6632
6633                         //mt:len32
6634                         Texture
6635
6636                         ID           ParticleSpawnerID
6637                         Vertical     bool
6638                         CollisionRm  bool
6639                         AttachedAOID AOID
6640                         AnimParams   TileAnim
6641                         Glow         uint8
6642                         AOCollision  bool
6643                         NodeParam0   Content
6644                         NodeParam2   uint8
6645                         NodeTile     uint8
6646                 }))(obj)).Vel)[local164] {
6647                         {
6648                                 p := &(((*(*(struct {
6649                                         Amount         uint16
6650                                         Duration       float32
6651                                         Pos, Vel, Acc  [2][3]float32
6652                                         ExpirationTime [2]float32 // in seconds.
6653                                         Size           [2]float32
6654                                         Collide        bool
6655
6656                                         //mt:len32
6657                                         Texture
6658
6659                                         ID           ParticleSpawnerID
6660                                         Vertical     bool
6661                                         CollisionRm  bool
6662                                         AttachedAOID AOID
6663                                         AnimParams   TileAnim
6664                                         Glow         uint8
6665                                         AOCollision  bool
6666                                         NodeParam0   Content
6667                                         NodeParam2   uint8
6668                                         NodeTile     uint8
6669                                 }))(obj)).Vel)[local164])[local165]
6670                                 *p = math.Float32frombits(read32(r))
6671                         }
6672                 }
6673         }
6674         for local166 := range (*(*(struct {
6675                 Amount         uint16
6676                 Duration       float32
6677                 Pos, Vel, Acc  [2][3]float32
6678                 ExpirationTime [2]float32 // in seconds.
6679                 Size           [2]float32
6680                 Collide        bool
6681
6682                 //mt:len32
6683                 Texture
6684
6685                 ID           ParticleSpawnerID
6686                 Vertical     bool
6687                 CollisionRm  bool
6688                 AttachedAOID AOID
6689                 AnimParams   TileAnim
6690                 Glow         uint8
6691                 AOCollision  bool
6692                 NodeParam0   Content
6693                 NodeParam2   uint8
6694                 NodeTile     uint8
6695         }))(obj)).Acc {
6696                 for local167 := range ((*(*(struct {
6697                         Amount         uint16
6698                         Duration       float32
6699                         Pos, Vel, Acc  [2][3]float32
6700                         ExpirationTime [2]float32 // in seconds.
6701                         Size           [2]float32
6702                         Collide        bool
6703
6704                         //mt:len32
6705                         Texture
6706
6707                         ID           ParticleSpawnerID
6708                         Vertical     bool
6709                         CollisionRm  bool
6710                         AttachedAOID AOID
6711                         AnimParams   TileAnim
6712                         Glow         uint8
6713                         AOCollision  bool
6714                         NodeParam0   Content
6715                         NodeParam2   uint8
6716                         NodeTile     uint8
6717                 }))(obj)).Acc)[local166] {
6718                         {
6719                                 p := &(((*(*(struct {
6720                                         Amount         uint16
6721                                         Duration       float32
6722                                         Pos, Vel, Acc  [2][3]float32
6723                                         ExpirationTime [2]float32 // in seconds.
6724                                         Size           [2]float32
6725                                         Collide        bool
6726
6727                                         //mt:len32
6728                                         Texture
6729
6730                                         ID           ParticleSpawnerID
6731                                         Vertical     bool
6732                                         CollisionRm  bool
6733                                         AttachedAOID AOID
6734                                         AnimParams   TileAnim
6735                                         Glow         uint8
6736                                         AOCollision  bool
6737                                         NodeParam0   Content
6738                                         NodeParam2   uint8
6739                                         NodeTile     uint8
6740                                 }))(obj)).Acc)[local166])[local167]
6741                                 *p = math.Float32frombits(read32(r))
6742                         }
6743                 }
6744         }
6745         for local168 := range (*(*(struct {
6746                 Amount         uint16
6747                 Duration       float32
6748                 Pos, Vel, Acc  [2][3]float32
6749                 ExpirationTime [2]float32 // in seconds.
6750                 Size           [2]float32
6751                 Collide        bool
6752
6753                 //mt:len32
6754                 Texture
6755
6756                 ID           ParticleSpawnerID
6757                 Vertical     bool
6758                 CollisionRm  bool
6759                 AttachedAOID AOID
6760                 AnimParams   TileAnim
6761                 Glow         uint8
6762                 AOCollision  bool
6763                 NodeParam0   Content
6764                 NodeParam2   uint8
6765                 NodeTile     uint8
6766         }))(obj)).ExpirationTime {
6767                 {
6768                         p := &((*(*(struct {
6769                                 Amount         uint16
6770                                 Duration       float32
6771                                 Pos, Vel, Acc  [2][3]float32
6772                                 ExpirationTime [2]float32 // in seconds.
6773                                 Size           [2]float32
6774                                 Collide        bool
6775
6776                                 //mt:len32
6777                                 Texture
6778
6779                                 ID           ParticleSpawnerID
6780                                 Vertical     bool
6781                                 CollisionRm  bool
6782                                 AttachedAOID AOID
6783                                 AnimParams   TileAnim
6784                                 Glow         uint8
6785                                 AOCollision  bool
6786                                 NodeParam0   Content
6787                                 NodeParam2   uint8
6788                                 NodeTile     uint8
6789                         }))(obj)).ExpirationTime)[local168]
6790                         *p = math.Float32frombits(read32(r))
6791                 }
6792         }
6793         for local169 := range (*(*(struct {
6794                 Amount         uint16
6795                 Duration       float32
6796                 Pos, Vel, Acc  [2][3]float32
6797                 ExpirationTime [2]float32 // in seconds.
6798                 Size           [2]float32
6799                 Collide        bool
6800
6801                 //mt:len32
6802                 Texture
6803
6804                 ID           ParticleSpawnerID
6805                 Vertical     bool
6806                 CollisionRm  bool
6807                 AttachedAOID AOID
6808                 AnimParams   TileAnim
6809                 Glow         uint8
6810                 AOCollision  bool
6811                 NodeParam0   Content
6812                 NodeParam2   uint8
6813                 NodeTile     uint8
6814         }))(obj)).Size {
6815                 {
6816                         p := &((*(*(struct {
6817                                 Amount         uint16
6818                                 Duration       float32
6819                                 Pos, Vel, Acc  [2][3]float32
6820                                 ExpirationTime [2]float32 // in seconds.
6821                                 Size           [2]float32
6822                                 Collide        bool
6823
6824                                 //mt:len32
6825                                 Texture
6826
6827                                 ID           ParticleSpawnerID
6828                                 Vertical     bool
6829                                 CollisionRm  bool
6830                                 AttachedAOID AOID
6831                                 AnimParams   TileAnim
6832                                 Glow         uint8
6833                                 AOCollision  bool
6834                                 NodeParam0   Content
6835                                 NodeParam2   uint8
6836                                 NodeTile     uint8
6837                         }))(obj)).Size)[local169]
6838                         *p = math.Float32frombits(read32(r))
6839                 }
6840         }
6841         {
6842                 p := &(*(*(struct {
6843                         Amount         uint16
6844                         Duration       float32
6845                         Pos, Vel, Acc  [2][3]float32
6846                         ExpirationTime [2]float32 // in seconds.
6847                         Size           [2]float32
6848                         Collide        bool
6849
6850                         //mt:len32
6851                         Texture
6852
6853                         ID           ParticleSpawnerID
6854                         Vertical     bool
6855                         CollisionRm  bool
6856                         AttachedAOID AOID
6857                         AnimParams   TileAnim
6858                         Glow         uint8
6859                         AOCollision  bool
6860                         NodeParam0   Content
6861                         NodeParam2   uint8
6862                         NodeTile     uint8
6863                 }))(obj)).Collide
6864                 switch n := read8(r); n {
6865                 case 0:
6866                         *p = false
6867                 case 1:
6868                         *p = true
6869                 default:
6870                         chk(fmt.Errorf("invalid bool: %d", n))
6871                 }
6872         }
6873         var local170 []uint8
6874         var local171 uint32
6875         {
6876                 p := &local171
6877                 *p = read32(r)
6878         }
6879         (local170) = make([]uint8, local171)
6880         {
6881                 _, err := io.ReadFull(r, (local170)[:])
6882                 chk(err)
6883         }
6884         (*(*string)(&((*(*(struct {
6885                 Amount         uint16
6886                 Duration       float32
6887                 Pos, Vel, Acc  [2][3]float32
6888                 ExpirationTime [2]float32 // in seconds.
6889                 Size           [2]float32
6890                 Collide        bool
6891
6892                 //mt:len32
6893                 Texture
6894
6895                 ID           ParticleSpawnerID
6896                 Vertical     bool
6897                 CollisionRm  bool
6898                 AttachedAOID AOID
6899                 AnimParams   TileAnim
6900                 Glow         uint8
6901                 AOCollision  bool
6902                 NodeParam0   Content
6903                 NodeParam2   uint8
6904                 NodeTile     uint8
6905         }))(obj)).Texture))) = string(local170)
6906         if err := pcall(func() {
6907                 ((*(*(struct {
6908                         Amount         uint16
6909                         Duration       float32
6910                         Pos, Vel, Acc  [2][3]float32
6911                         ExpirationTime [2]float32 // in seconds.
6912                         Size           [2]float32
6913                         Collide        bool
6914
6915                         //mt:len32
6916                         Texture
6917
6918                         ID           ParticleSpawnerID
6919                         Vertical     bool
6920                         CollisionRm  bool
6921                         AttachedAOID AOID
6922                         AnimParams   TileAnim
6923                         Glow         uint8
6924                         AOCollision  bool
6925                         NodeParam0   Content
6926                         NodeParam2   uint8
6927                         NodeTile     uint8
6928                 }))(obj)).ID).deserialize(r)
6929         }); err != nil {
6930                 if err == io.EOF {
6931                         chk(io.EOF)
6932                 }
6933                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6934         }
6935         {
6936                 p := &(*(*(struct {
6937                         Amount         uint16
6938                         Duration       float32
6939                         Pos, Vel, Acc  [2][3]float32
6940                         ExpirationTime [2]float32 // in seconds.
6941                         Size           [2]float32
6942                         Collide        bool
6943
6944                         //mt:len32
6945                         Texture
6946
6947                         ID           ParticleSpawnerID
6948                         Vertical     bool
6949                         CollisionRm  bool
6950                         AttachedAOID AOID
6951                         AnimParams   TileAnim
6952                         Glow         uint8
6953                         AOCollision  bool
6954                         NodeParam0   Content
6955                         NodeParam2   uint8
6956                         NodeTile     uint8
6957                 }))(obj)).Vertical
6958                 switch n := read8(r); n {
6959                 case 0:
6960                         *p = false
6961                 case 1:
6962                         *p = true
6963                 default:
6964                         chk(fmt.Errorf("invalid bool: %d", n))
6965                 }
6966         }
6967         {
6968                 p := &(*(*(struct {
6969                         Amount         uint16
6970                         Duration       float32
6971                         Pos, Vel, Acc  [2][3]float32
6972                         ExpirationTime [2]float32 // in seconds.
6973                         Size           [2]float32
6974                         Collide        bool
6975
6976                         //mt:len32
6977                         Texture
6978
6979                         ID           ParticleSpawnerID
6980                         Vertical     bool
6981                         CollisionRm  bool
6982                         AttachedAOID AOID
6983                         AnimParams   TileAnim
6984                         Glow         uint8
6985                         AOCollision  bool
6986                         NodeParam0   Content
6987                         NodeParam2   uint8
6988                         NodeTile     uint8
6989                 }))(obj)).CollisionRm
6990                 switch n := read8(r); n {
6991                 case 0:
6992                         *p = false
6993                 case 1:
6994                         *p = true
6995                 default:
6996                         chk(fmt.Errorf("invalid bool: %d", n))
6997                 }
6998         }
6999         if err := pcall(func() {
7000                 ((*(*(struct {
7001                         Amount         uint16
7002                         Duration       float32
7003                         Pos, Vel, Acc  [2][3]float32
7004                         ExpirationTime [2]float32 // in seconds.
7005                         Size           [2]float32
7006                         Collide        bool
7007
7008                         //mt:len32
7009                         Texture
7010
7011                         ID           ParticleSpawnerID
7012                         Vertical     bool
7013                         CollisionRm  bool
7014                         AttachedAOID AOID
7015                         AnimParams   TileAnim
7016                         Glow         uint8
7017                         AOCollision  bool
7018                         NodeParam0   Content
7019                         NodeParam2   uint8
7020                         NodeTile     uint8
7021                 }))(obj)).AttachedAOID).deserialize(r)
7022         }); err != nil {
7023                 if err == io.EOF {
7024                         chk(io.EOF)
7025                 }
7026                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
7027         }
7028         if err := pcall(func() {
7029                 ((*(*(struct {
7030                         Amount         uint16
7031                         Duration       float32
7032                         Pos, Vel, Acc  [2][3]float32
7033                         ExpirationTime [2]float32 // in seconds.
7034                         Size           [2]float32
7035                         Collide        bool
7036
7037                         //mt:len32
7038                         Texture
7039
7040                         ID           ParticleSpawnerID
7041                         Vertical     bool
7042                         CollisionRm  bool
7043                         AttachedAOID AOID
7044                         AnimParams   TileAnim
7045                         Glow         uint8
7046                         AOCollision  bool
7047                         NodeParam0   Content
7048                         NodeParam2   uint8
7049                         NodeTile     uint8
7050                 }))(obj)).AnimParams).deserialize(r)
7051         }); err != nil {
7052                 if err == io.EOF {
7053                         chk(io.EOF)
7054                 }
7055                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
7056         }
7057         {
7058                 p := &(*(*(struct {
7059                         Amount         uint16
7060                         Duration       float32
7061                         Pos, Vel, Acc  [2][3]float32
7062                         ExpirationTime [2]float32 // in seconds.
7063                         Size           [2]float32
7064                         Collide        bool
7065
7066                         //mt:len32
7067                         Texture
7068
7069                         ID           ParticleSpawnerID
7070                         Vertical     bool
7071                         CollisionRm  bool
7072                         AttachedAOID AOID
7073                         AnimParams   TileAnim
7074                         Glow         uint8
7075                         AOCollision  bool
7076                         NodeParam0   Content
7077                         NodeParam2   uint8
7078                         NodeTile     uint8
7079                 }))(obj)).Glow
7080                 *p = read8(r)
7081         }
7082         {
7083                 p := &(*(*(struct {
7084                         Amount         uint16
7085                         Duration       float32
7086                         Pos, Vel, Acc  [2][3]float32
7087                         ExpirationTime [2]float32 // in seconds.
7088                         Size           [2]float32
7089                         Collide        bool
7090
7091                         //mt:len32
7092                         Texture
7093
7094                         ID           ParticleSpawnerID
7095                         Vertical     bool
7096                         CollisionRm  bool
7097                         AttachedAOID AOID
7098                         AnimParams   TileAnim
7099                         Glow         uint8
7100                         AOCollision  bool
7101                         NodeParam0   Content
7102                         NodeParam2   uint8
7103                         NodeTile     uint8
7104                 }))(obj)).AOCollision
7105                 switch n := read8(r); n {
7106                 case 0:
7107                         *p = false
7108                 case 1:
7109                         *p = true
7110                 default:
7111                         chk(fmt.Errorf("invalid bool: %d", n))
7112                 }
7113         }
7114         if err := pcall(func() {
7115                 ((*(*(struct {
7116                         Amount         uint16
7117                         Duration       float32
7118                         Pos, Vel, Acc  [2][3]float32
7119                         ExpirationTime [2]float32 // in seconds.
7120                         Size           [2]float32
7121                         Collide        bool
7122
7123                         //mt:len32
7124                         Texture
7125
7126                         ID           ParticleSpawnerID
7127                         Vertical     bool
7128                         CollisionRm  bool
7129                         AttachedAOID AOID
7130                         AnimParams   TileAnim
7131                         Glow         uint8
7132                         AOCollision  bool
7133                         NodeParam0   Content
7134                         NodeParam2   uint8
7135                         NodeTile     uint8
7136                 }))(obj)).NodeParam0).deserialize(r)
7137         }); err != nil {
7138                 if err == io.EOF {
7139                         chk(io.EOF)
7140                 }
7141                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
7142         }
7143         {
7144                 p := &(*(*(struct {
7145                         Amount         uint16
7146                         Duration       float32
7147                         Pos, Vel, Acc  [2][3]float32
7148                         ExpirationTime [2]float32 // in seconds.
7149                         Size           [2]float32
7150                         Collide        bool
7151
7152                         //mt:len32
7153                         Texture
7154
7155                         ID           ParticleSpawnerID
7156                         Vertical     bool
7157                         CollisionRm  bool
7158                         AttachedAOID AOID
7159                         AnimParams   TileAnim
7160                         Glow         uint8
7161                         AOCollision  bool
7162                         NodeParam0   Content
7163                         NodeParam2   uint8
7164                         NodeTile     uint8
7165                 }))(obj)).NodeParam2
7166                 *p = read8(r)
7167         }
7168         {
7169                 p := &(*(*(struct {
7170                         Amount         uint16
7171                         Duration       float32
7172                         Pos, Vel, Acc  [2][3]float32
7173                         ExpirationTime [2]float32 // in seconds.
7174                         Size           [2]float32
7175                         Collide        bool
7176
7177                         //mt:len32
7178                         Texture
7179
7180                         ID           ParticleSpawnerID
7181                         Vertical     bool
7182                         CollisionRm  bool
7183                         AttachedAOID AOID
7184                         AnimParams   TileAnim
7185                         Glow         uint8
7186                         AOCollision  bool
7187                         NodeParam0   Content
7188                         NodeParam2   uint8
7189                         NodeTile     uint8
7190                 }))(obj)).NodeTile
7191                 *p = read8(r)
7192         }
7193 }
7194
7195 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7196         if err := pcall(func() {
7197                 ((*(*(struct {
7198                         ID HUDID
7199                         HUD
7200                 }))(obj)).ID).serialize(w)
7201         }); err != nil {
7202                 if err == io.EOF {
7203                         chk(io.EOF)
7204                 }
7205                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7206         }
7207         if err := pcall(func() {
7208                 ((*(*(struct {
7209                         ID HUDID
7210                         HUD
7211                 }))(obj)).HUD).serialize(w)
7212         }); err != nil {
7213                 if err == io.EOF {
7214                         chk(io.EOF)
7215                 }
7216                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7217         }
7218 }
7219
7220 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
7221         if err := pcall(func() {
7222                 ((*(*(struct {
7223                         ID HUDID
7224                         HUD
7225                 }))(obj)).ID).deserialize(r)
7226         }); err != nil {
7227                 if err == io.EOF {
7228                         chk(io.EOF)
7229                 }
7230                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7231         }
7232         if err := pcall(func() {
7233                 ((*(*(struct {
7234                         ID HUDID
7235                         HUD
7236                 }))(obj)).HUD).deserialize(r)
7237         }); err != nil {
7238                 if err == io.EOF {
7239                         chk(io.EOF)
7240                 }
7241                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7242         }
7243 }
7244
7245 func (obj *ToCltRmHUD) serialize(w io.Writer) {
7246         if err := pcall(func() {
7247                 ((*(*(struct {
7248                         ID HUDID
7249                 }))(obj)).ID).serialize(w)
7250         }); err != nil {
7251                 if err == io.EOF {
7252                         chk(io.EOF)
7253                 }
7254                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7255         }
7256 }
7257
7258 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
7259         if err := pcall(func() {
7260                 ((*(*(struct {
7261                         ID HUDID
7262                 }))(obj)).ID).deserialize(r)
7263         }); err != nil {
7264                 if err == io.EOF {
7265                         chk(io.EOF)
7266                 }
7267                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7268         }
7269 }
7270
7271 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
7272         if err := pcall(func() {
7273                 ((*(*(struct {
7274                         ID HUDID
7275
7276                         Field HUDField
7277
7278                         //mt:if %s.Field == HUDPos
7279                         Pos [2]float32
7280
7281                         //mt:if %s.Field == HUDName
7282                         Name string
7283
7284                         //mt:if %s.Field == HUDScale
7285                         Scale [2]float32
7286
7287                         //mt:if %s.Field == HUDText
7288                         Text string
7289
7290                         //mt:if %s.Field == HUDNumber
7291                         Number uint32
7292
7293                         //mt:if %s.Field == HUDItem
7294                         Item uint32
7295
7296                         //mt:if %s.Field == HUDDir
7297                         Dir uint32
7298
7299                         //mt:if %s.Field == HUDAlign
7300                         Align [2]float32
7301
7302                         //mt:if %s.Field == HUDOffset
7303                         Offset [2]float32
7304
7305                         //mt:if %s.Field == HUDWorldPos
7306                         WorldPos Pos
7307
7308                         //mt:if %s.Field == HUDSize
7309                         Size [2]int32
7310
7311                         //mt:if %s.Field == HUDZIndex
7312                         ZIndex int32
7313
7314                         //mt:if %s.Field == HUDText2
7315                         Text2 string
7316
7317                         //mt:if %s.Field == HUDStyle
7318                         Style HUDStyleFlags
7319                 }))(obj)).ID).serialize(w)
7320         }); err != nil {
7321                 if err == io.EOF {
7322                         chk(io.EOF)
7323                 }
7324                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7325         }
7326         if err := pcall(func() {
7327                 ((*(*(struct {
7328                         ID HUDID
7329
7330                         Field HUDField
7331
7332                         //mt:if %s.Field == HUDPos
7333                         Pos [2]float32
7334
7335                         //mt:if %s.Field == HUDName
7336                         Name string
7337
7338                         //mt:if %s.Field == HUDScale
7339                         Scale [2]float32
7340
7341                         //mt:if %s.Field == HUDText
7342                         Text string
7343
7344                         //mt:if %s.Field == HUDNumber
7345                         Number uint32
7346
7347                         //mt:if %s.Field == HUDItem
7348                         Item uint32
7349
7350                         //mt:if %s.Field == HUDDir
7351                         Dir uint32
7352
7353                         //mt:if %s.Field == HUDAlign
7354                         Align [2]float32
7355
7356                         //mt:if %s.Field == HUDOffset
7357                         Offset [2]float32
7358
7359                         //mt:if %s.Field == HUDWorldPos
7360                         WorldPos Pos
7361
7362                         //mt:if %s.Field == HUDSize
7363                         Size [2]int32
7364
7365                         //mt:if %s.Field == HUDZIndex
7366                         ZIndex int32
7367
7368                         //mt:if %s.Field == HUDText2
7369                         Text2 string
7370
7371                         //mt:if %s.Field == HUDStyle
7372                         Style HUDStyleFlags
7373                 }))(obj)).Field).serialize(w)
7374         }); err != nil {
7375                 if err == io.EOF {
7376                         chk(io.EOF)
7377                 }
7378                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
7379         }
7380         if !((*(*(struct {
7381                 ID HUDID
7382
7383                 Field HUDField
7384
7385                 //mt:if %s.Field == HUDPos
7386                 Pos [2]float32
7387
7388                 //mt:if %s.Field == HUDName
7389                 Name string
7390
7391                 //mt:if %s.Field == HUDScale
7392                 Scale [2]float32
7393
7394                 //mt:if %s.Field == HUDText
7395                 Text string
7396
7397                 //mt:if %s.Field == HUDNumber
7398                 Number uint32
7399
7400                 //mt:if %s.Field == HUDItem
7401                 Item uint32
7402
7403                 //mt:if %s.Field == HUDDir
7404                 Dir uint32
7405
7406                 //mt:if %s.Field == HUDAlign
7407                 Align [2]float32
7408
7409                 //mt:if %s.Field == HUDOffset
7410                 Offset [2]float32
7411
7412                 //mt:if %s.Field == HUDWorldPos
7413                 WorldPos Pos
7414
7415                 //mt:if %s.Field == HUDSize
7416                 Size [2]int32
7417
7418                 //mt:if %s.Field == HUDZIndex
7419                 ZIndex int32
7420
7421                 //mt:if %s.Field == HUDText2
7422                 Text2 string
7423
7424                 //mt:if %s.Field == HUDStyle
7425                 Style HUDStyleFlags
7426         }))(obj)).Field < hudMax) {
7427                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7428         }
7429         if (*(*(struct {
7430                 ID HUDID
7431
7432                 Field HUDField
7433
7434                 //mt:if %s.Field == HUDPos
7435                 Pos [2]float32
7436
7437                 //mt:if %s.Field == HUDName
7438                 Name string
7439
7440                 //mt:if %s.Field == HUDScale
7441                 Scale [2]float32
7442
7443                 //mt:if %s.Field == HUDText
7444                 Text string
7445
7446                 //mt:if %s.Field == HUDNumber
7447                 Number uint32
7448
7449                 //mt:if %s.Field == HUDItem
7450                 Item uint32
7451
7452                 //mt:if %s.Field == HUDDir
7453                 Dir uint32
7454
7455                 //mt:if %s.Field == HUDAlign
7456                 Align [2]float32
7457
7458                 //mt:if %s.Field == HUDOffset
7459                 Offset [2]float32
7460
7461                 //mt:if %s.Field == HUDWorldPos
7462                 WorldPos Pos
7463
7464                 //mt:if %s.Field == HUDSize
7465                 Size [2]int32
7466
7467                 //mt:if %s.Field == HUDZIndex
7468                 ZIndex int32
7469
7470                 //mt:if %s.Field == HUDText2
7471                 Text2 string
7472
7473                 //mt:if %s.Field == HUDStyle
7474                 Style HUDStyleFlags
7475         }))(obj)).Field == HUDPos {
7476                 for local172 := range (*(*(struct {
7477                         ID HUDID
7478
7479                         Field HUDField
7480
7481                         //mt:if %s.Field == HUDPos
7482                         Pos [2]float32
7483
7484                         //mt:if %s.Field == HUDName
7485                         Name string
7486
7487                         //mt:if %s.Field == HUDScale
7488                         Scale [2]float32
7489
7490                         //mt:if %s.Field == HUDText
7491                         Text string
7492
7493                         //mt:if %s.Field == HUDNumber
7494                         Number uint32
7495
7496                         //mt:if %s.Field == HUDItem
7497                         Item uint32
7498
7499                         //mt:if %s.Field == HUDDir
7500                         Dir uint32
7501
7502                         //mt:if %s.Field == HUDAlign
7503                         Align [2]float32
7504
7505                         //mt:if %s.Field == HUDOffset
7506                         Offset [2]float32
7507
7508                         //mt:if %s.Field == HUDWorldPos
7509                         WorldPos Pos
7510
7511                         //mt:if %s.Field == HUDSize
7512                         Size [2]int32
7513
7514                         //mt:if %s.Field == HUDZIndex
7515                         ZIndex int32
7516
7517                         //mt:if %s.Field == HUDText2
7518                         Text2 string
7519
7520                         //mt:if %s.Field == HUDStyle
7521                         Style HUDStyleFlags
7522                 }))(obj)).Pos {
7523                         {
7524                                 x := ((*(*(struct {
7525                                         ID HUDID
7526
7527                                         Field HUDField
7528
7529                                         //mt:if %s.Field == HUDPos
7530                                         Pos [2]float32
7531
7532                                         //mt:if %s.Field == HUDName
7533                                         Name string
7534
7535                                         //mt:if %s.Field == HUDScale
7536                                         Scale [2]float32
7537
7538                                         //mt:if %s.Field == HUDText
7539                                         Text string
7540
7541                                         //mt:if %s.Field == HUDNumber
7542                                         Number uint32
7543
7544                                         //mt:if %s.Field == HUDItem
7545                                         Item uint32
7546
7547                                         //mt:if %s.Field == HUDDir
7548                                         Dir uint32
7549
7550                                         //mt:if %s.Field == HUDAlign
7551                                         Align [2]float32
7552
7553                                         //mt:if %s.Field == HUDOffset
7554                                         Offset [2]float32
7555
7556                                         //mt:if %s.Field == HUDWorldPos
7557                                         WorldPos Pos
7558
7559                                         //mt:if %s.Field == HUDSize
7560                                         Size [2]int32
7561
7562                                         //mt:if %s.Field == HUDZIndex
7563                                         ZIndex int32
7564
7565                                         //mt:if %s.Field == HUDText2
7566                                         Text2 string
7567
7568                                         //mt:if %s.Field == HUDStyle
7569                                         Style HUDStyleFlags
7570                                 }))(obj)).Pos)[local172]
7571                                 write32(w, math.Float32bits(x))
7572                         }
7573                 }
7574         }
7575         if (*(*(struct {
7576                 ID HUDID
7577
7578                 Field HUDField
7579
7580                 //mt:if %s.Field == HUDPos
7581                 Pos [2]float32
7582
7583                 //mt:if %s.Field == HUDName
7584                 Name string
7585
7586                 //mt:if %s.Field == HUDScale
7587                 Scale [2]float32
7588
7589                 //mt:if %s.Field == HUDText
7590                 Text string
7591
7592                 //mt:if %s.Field == HUDNumber
7593                 Number uint32
7594
7595                 //mt:if %s.Field == HUDItem
7596                 Item uint32
7597
7598                 //mt:if %s.Field == HUDDir
7599                 Dir uint32
7600
7601                 //mt:if %s.Field == HUDAlign
7602                 Align [2]float32
7603
7604                 //mt:if %s.Field == HUDOffset
7605                 Offset [2]float32
7606
7607                 //mt:if %s.Field == HUDWorldPos
7608                 WorldPos Pos
7609
7610                 //mt:if %s.Field == HUDSize
7611                 Size [2]int32
7612
7613                 //mt:if %s.Field == HUDZIndex
7614                 ZIndex int32
7615
7616                 //mt:if %s.Field == HUDText2
7617                 Text2 string
7618
7619                 //mt:if %s.Field == HUDStyle
7620                 Style HUDStyleFlags
7621         }))(obj)).Field == HUDName {
7622                 if len(([]byte((*(*(struct {
7623                         ID HUDID
7624
7625                         Field HUDField
7626
7627                         //mt:if %s.Field == HUDPos
7628                         Pos [2]float32
7629
7630                         //mt:if %s.Field == HUDName
7631                         Name string
7632
7633                         //mt:if %s.Field == HUDScale
7634                         Scale [2]float32
7635
7636                         //mt:if %s.Field == HUDText
7637                         Text string
7638
7639                         //mt:if %s.Field == HUDNumber
7640                         Number uint32
7641
7642                         //mt:if %s.Field == HUDItem
7643                         Item uint32
7644
7645                         //mt:if %s.Field == HUDDir
7646                         Dir uint32
7647
7648                         //mt:if %s.Field == HUDAlign
7649                         Align [2]float32
7650
7651                         //mt:if %s.Field == HUDOffset
7652                         Offset [2]float32
7653
7654                         //mt:if %s.Field == HUDWorldPos
7655                         WorldPos Pos
7656
7657                         //mt:if %s.Field == HUDSize
7658                         Size [2]int32
7659
7660                         //mt:if %s.Field == HUDZIndex
7661                         ZIndex int32
7662
7663                         //mt:if %s.Field == HUDText2
7664                         Text2 string
7665
7666                         //mt:if %s.Field == HUDStyle
7667                         Style HUDStyleFlags
7668                 }))(obj)).Name))) > math.MaxUint16 {
7669                         chk(ErrTooLong)
7670                 }
7671                 {
7672                         x := uint16(len(([]byte((*(*(struct {
7673                                 ID HUDID
7674
7675                                 Field HUDField
7676
7677                                 //mt:if %s.Field == HUDPos
7678                                 Pos [2]float32
7679
7680                                 //mt:if %s.Field == HUDName
7681                                 Name string
7682
7683                                 //mt:if %s.Field == HUDScale
7684                                 Scale [2]float32
7685
7686                                 //mt:if %s.Field == HUDText
7687                                 Text string
7688
7689                                 //mt:if %s.Field == HUDNumber
7690                                 Number uint32
7691
7692                                 //mt:if %s.Field == HUDItem
7693                                 Item uint32
7694
7695                                 //mt:if %s.Field == HUDDir
7696                                 Dir uint32
7697
7698                                 //mt:if %s.Field == HUDAlign
7699                                 Align [2]float32
7700
7701                                 //mt:if %s.Field == HUDOffset
7702                                 Offset [2]float32
7703
7704                                 //mt:if %s.Field == HUDWorldPos
7705                                 WorldPos Pos
7706
7707                                 //mt:if %s.Field == HUDSize
7708                                 Size [2]int32
7709
7710                                 //mt:if %s.Field == HUDZIndex
7711                                 ZIndex int32
7712
7713                                 //mt:if %s.Field == HUDText2
7714                                 Text2 string
7715
7716                                 //mt:if %s.Field == HUDStyle
7717                                 Style HUDStyleFlags
7718                         }))(obj)).Name))))
7719                         write16(w, uint16(x))
7720                 }
7721                 {
7722                         _, err := w.Write(([]byte((*(*(struct {
7723                                 ID HUDID
7724
7725                                 Field HUDField
7726
7727                                 //mt:if %s.Field == HUDPos
7728                                 Pos [2]float32
7729
7730                                 //mt:if %s.Field == HUDName
7731                                 Name string
7732
7733                                 //mt:if %s.Field == HUDScale
7734                                 Scale [2]float32
7735
7736                                 //mt:if %s.Field == HUDText
7737                                 Text string
7738
7739                                 //mt:if %s.Field == HUDNumber
7740                                 Number uint32
7741
7742                                 //mt:if %s.Field == HUDItem
7743                                 Item uint32
7744
7745                                 //mt:if %s.Field == HUDDir
7746                                 Dir uint32
7747
7748                                 //mt:if %s.Field == HUDAlign
7749                                 Align [2]float32
7750
7751                                 //mt:if %s.Field == HUDOffset
7752                                 Offset [2]float32
7753
7754                                 //mt:if %s.Field == HUDWorldPos
7755                                 WorldPos Pos
7756
7757                                 //mt:if %s.Field == HUDSize
7758                                 Size [2]int32
7759
7760                                 //mt:if %s.Field == HUDZIndex
7761                                 ZIndex int32
7762
7763                                 //mt:if %s.Field == HUDText2
7764                                 Text2 string
7765
7766                                 //mt:if %s.Field == HUDStyle
7767                                 Style HUDStyleFlags
7768                         }))(obj)).Name))[:])
7769                         chk(err)
7770                 }
7771         }
7772         if (*(*(struct {
7773                 ID HUDID
7774
7775                 Field HUDField
7776
7777                 //mt:if %s.Field == HUDPos
7778                 Pos [2]float32
7779
7780                 //mt:if %s.Field == HUDName
7781                 Name string
7782
7783                 //mt:if %s.Field == HUDScale
7784                 Scale [2]float32
7785
7786                 //mt:if %s.Field == HUDText
7787                 Text string
7788
7789                 //mt:if %s.Field == HUDNumber
7790                 Number uint32
7791
7792                 //mt:if %s.Field == HUDItem
7793                 Item uint32
7794
7795                 //mt:if %s.Field == HUDDir
7796                 Dir uint32
7797
7798                 //mt:if %s.Field == HUDAlign
7799                 Align [2]float32
7800
7801                 //mt:if %s.Field == HUDOffset
7802                 Offset [2]float32
7803
7804                 //mt:if %s.Field == HUDWorldPos
7805                 WorldPos Pos
7806
7807                 //mt:if %s.Field == HUDSize
7808                 Size [2]int32
7809
7810                 //mt:if %s.Field == HUDZIndex
7811                 ZIndex int32
7812
7813                 //mt:if %s.Field == HUDText2
7814                 Text2 string
7815
7816                 //mt:if %s.Field == HUDStyle
7817                 Style HUDStyleFlags
7818         }))(obj)).Field == HUDScale {
7819                 for local173 := range (*(*(struct {
7820                         ID HUDID
7821
7822                         Field HUDField
7823
7824                         //mt:if %s.Field == HUDPos
7825                         Pos [2]float32
7826
7827                         //mt:if %s.Field == HUDName
7828                         Name string
7829
7830                         //mt:if %s.Field == HUDScale
7831                         Scale [2]float32
7832
7833                         //mt:if %s.Field == HUDText
7834                         Text string
7835
7836                         //mt:if %s.Field == HUDNumber
7837                         Number uint32
7838
7839                         //mt:if %s.Field == HUDItem
7840                         Item uint32
7841
7842                         //mt:if %s.Field == HUDDir
7843                         Dir uint32
7844
7845                         //mt:if %s.Field == HUDAlign
7846                         Align [2]float32
7847
7848                         //mt:if %s.Field == HUDOffset
7849                         Offset [2]float32
7850
7851                         //mt:if %s.Field == HUDWorldPos
7852                         WorldPos Pos
7853
7854                         //mt:if %s.Field == HUDSize
7855                         Size [2]int32
7856
7857                         //mt:if %s.Field == HUDZIndex
7858                         ZIndex int32
7859
7860                         //mt:if %s.Field == HUDText2
7861                         Text2 string
7862
7863                         //mt:if %s.Field == HUDStyle
7864                         Style HUDStyleFlags
7865                 }))(obj)).Scale {
7866                         {
7867                                 x := ((*(*(struct {
7868                                         ID HUDID
7869
7870                                         Field HUDField
7871
7872                                         //mt:if %s.Field == HUDPos
7873                                         Pos [2]float32
7874
7875                                         //mt:if %s.Field == HUDName
7876                                         Name string
7877
7878                                         //mt:if %s.Field == HUDScale
7879                                         Scale [2]float32
7880
7881                                         //mt:if %s.Field == HUDText
7882                                         Text string
7883
7884                                         //mt:if %s.Field == HUDNumber
7885                                         Number uint32
7886
7887                                         //mt:if %s.Field == HUDItem
7888                                         Item uint32
7889
7890                                         //mt:if %s.Field == HUDDir
7891                                         Dir uint32
7892
7893                                         //mt:if %s.Field == HUDAlign
7894                                         Align [2]float32
7895
7896                                         //mt:if %s.Field == HUDOffset
7897                                         Offset [2]float32
7898
7899                                         //mt:if %s.Field == HUDWorldPos
7900                                         WorldPos Pos
7901
7902                                         //mt:if %s.Field == HUDSize
7903                                         Size [2]int32
7904
7905                                         //mt:if %s.Field == HUDZIndex
7906                                         ZIndex int32
7907
7908                                         //mt:if %s.Field == HUDText2
7909                                         Text2 string
7910
7911                                         //mt:if %s.Field == HUDStyle
7912                                         Style HUDStyleFlags
7913                                 }))(obj)).Scale)[local173]
7914                                 write32(w, math.Float32bits(x))
7915                         }
7916                 }
7917         }
7918         if (*(*(struct {
7919                 ID HUDID
7920
7921                 Field HUDField
7922
7923                 //mt:if %s.Field == HUDPos
7924                 Pos [2]float32
7925
7926                 //mt:if %s.Field == HUDName
7927                 Name string
7928
7929                 //mt:if %s.Field == HUDScale
7930                 Scale [2]float32
7931
7932                 //mt:if %s.Field == HUDText
7933                 Text string
7934
7935                 //mt:if %s.Field == HUDNumber
7936                 Number uint32
7937
7938                 //mt:if %s.Field == HUDItem
7939                 Item uint32
7940
7941                 //mt:if %s.Field == HUDDir
7942                 Dir uint32
7943
7944                 //mt:if %s.Field == HUDAlign
7945                 Align [2]float32
7946
7947                 //mt:if %s.Field == HUDOffset
7948                 Offset [2]float32
7949
7950                 //mt:if %s.Field == HUDWorldPos
7951                 WorldPos Pos
7952
7953                 //mt:if %s.Field == HUDSize
7954                 Size [2]int32
7955
7956                 //mt:if %s.Field == HUDZIndex
7957                 ZIndex int32
7958
7959                 //mt:if %s.Field == HUDText2
7960                 Text2 string
7961
7962                 //mt:if %s.Field == HUDStyle
7963                 Style HUDStyleFlags
7964         }))(obj)).Field == HUDText {
7965                 if len(([]byte((*(*(struct {
7966                         ID HUDID
7967
7968                         Field HUDField
7969
7970                         //mt:if %s.Field == HUDPos
7971                         Pos [2]float32
7972
7973                         //mt:if %s.Field == HUDName
7974                         Name string
7975
7976                         //mt:if %s.Field == HUDScale
7977                         Scale [2]float32
7978
7979                         //mt:if %s.Field == HUDText
7980                         Text string
7981
7982                         //mt:if %s.Field == HUDNumber
7983                         Number uint32
7984
7985                         //mt:if %s.Field == HUDItem
7986                         Item uint32
7987
7988                         //mt:if %s.Field == HUDDir
7989                         Dir uint32
7990
7991                         //mt:if %s.Field == HUDAlign
7992                         Align [2]float32
7993
7994                         //mt:if %s.Field == HUDOffset
7995                         Offset [2]float32
7996
7997                         //mt:if %s.Field == HUDWorldPos
7998                         WorldPos Pos
7999
8000                         //mt:if %s.Field == HUDSize
8001                         Size [2]int32
8002
8003                         //mt:if %s.Field == HUDZIndex
8004                         ZIndex int32
8005
8006                         //mt:if %s.Field == HUDText2
8007                         Text2 string
8008
8009                         //mt:if %s.Field == HUDStyle
8010                         Style HUDStyleFlags
8011                 }))(obj)).Text))) > math.MaxUint16 {
8012                         chk(ErrTooLong)
8013                 }
8014                 {
8015                         x := uint16(len(([]byte((*(*(struct {
8016                                 ID HUDID
8017
8018                                 Field HUDField
8019
8020                                 //mt:if %s.Field == HUDPos
8021                                 Pos [2]float32
8022
8023                                 //mt:if %s.Field == HUDName
8024                                 Name string
8025
8026                                 //mt:if %s.Field == HUDScale
8027                                 Scale [2]float32
8028
8029                                 //mt:if %s.Field == HUDText
8030                                 Text string
8031
8032                                 //mt:if %s.Field == HUDNumber
8033                                 Number uint32
8034
8035                                 //mt:if %s.Field == HUDItem
8036                                 Item uint32
8037
8038                                 //mt:if %s.Field == HUDDir
8039                                 Dir uint32
8040
8041                                 //mt:if %s.Field == HUDAlign
8042                                 Align [2]float32
8043
8044                                 //mt:if %s.Field == HUDOffset
8045                                 Offset [2]float32
8046
8047                                 //mt:if %s.Field == HUDWorldPos
8048                                 WorldPos Pos
8049
8050                                 //mt:if %s.Field == HUDSize
8051                                 Size [2]int32
8052
8053                                 //mt:if %s.Field == HUDZIndex
8054                                 ZIndex int32
8055
8056                                 //mt:if %s.Field == HUDText2
8057                                 Text2 string
8058
8059                                 //mt:if %s.Field == HUDStyle
8060                                 Style HUDStyleFlags
8061                         }))(obj)).Text))))
8062                         write16(w, uint16(x))
8063                 }
8064                 {
8065                         _, err := w.Write(([]byte((*(*(struct {
8066                                 ID HUDID
8067
8068                                 Field HUDField
8069
8070                                 //mt:if %s.Field == HUDPos
8071                                 Pos [2]float32
8072
8073                                 //mt:if %s.Field == HUDName
8074                                 Name string
8075
8076                                 //mt:if %s.Field == HUDScale
8077                                 Scale [2]float32
8078
8079                                 //mt:if %s.Field == HUDText
8080                                 Text string
8081
8082                                 //mt:if %s.Field == HUDNumber
8083                                 Number uint32
8084
8085                                 //mt:if %s.Field == HUDItem
8086                                 Item uint32
8087
8088                                 //mt:if %s.Field == HUDDir
8089                                 Dir uint32
8090
8091                                 //mt:if %s.Field == HUDAlign
8092                                 Align [2]float32
8093
8094                                 //mt:if %s.Field == HUDOffset
8095                                 Offset [2]float32
8096
8097                                 //mt:if %s.Field == HUDWorldPos
8098                                 WorldPos Pos
8099
8100                                 //mt:if %s.Field == HUDSize
8101                                 Size [2]int32
8102
8103                                 //mt:if %s.Field == HUDZIndex
8104                                 ZIndex int32
8105
8106                                 //mt:if %s.Field == HUDText2
8107                                 Text2 string
8108
8109                                 //mt:if %s.Field == HUDStyle
8110                                 Style HUDStyleFlags
8111                         }))(obj)).Text))[:])
8112                         chk(err)
8113                 }
8114         }
8115         if (*(*(struct {
8116                 ID HUDID
8117
8118                 Field HUDField
8119
8120                 //mt:if %s.Field == HUDPos
8121                 Pos [2]float32
8122
8123                 //mt:if %s.Field == HUDName
8124                 Name string
8125
8126                 //mt:if %s.Field == HUDScale
8127                 Scale [2]float32
8128
8129                 //mt:if %s.Field == HUDText
8130                 Text string
8131
8132                 //mt:if %s.Field == HUDNumber
8133                 Number uint32
8134
8135                 //mt:if %s.Field == HUDItem
8136                 Item uint32
8137
8138                 //mt:if %s.Field == HUDDir
8139                 Dir uint32
8140
8141                 //mt:if %s.Field == HUDAlign
8142                 Align [2]float32
8143
8144                 //mt:if %s.Field == HUDOffset
8145                 Offset [2]float32
8146
8147                 //mt:if %s.Field == HUDWorldPos
8148                 WorldPos Pos
8149
8150                 //mt:if %s.Field == HUDSize
8151                 Size [2]int32
8152
8153                 //mt:if %s.Field == HUDZIndex
8154                 ZIndex int32
8155
8156                 //mt:if %s.Field == HUDText2
8157                 Text2 string
8158
8159                 //mt:if %s.Field == HUDStyle
8160                 Style HUDStyleFlags
8161         }))(obj)).Field == HUDNumber {
8162                 {
8163                         x := (*(*(struct {
8164                                 ID HUDID
8165
8166                                 Field HUDField
8167
8168                                 //mt:if %s.Field == HUDPos
8169                                 Pos [2]float32
8170
8171                                 //mt:if %s.Field == HUDName
8172                                 Name string
8173
8174                                 //mt:if %s.Field == HUDScale
8175                                 Scale [2]float32
8176
8177                                 //mt:if %s.Field == HUDText
8178                                 Text string
8179
8180                                 //mt:if %s.Field == HUDNumber
8181                                 Number uint32
8182
8183                                 //mt:if %s.Field == HUDItem
8184                                 Item uint32
8185
8186                                 //mt:if %s.Field == HUDDir
8187                                 Dir uint32
8188
8189                                 //mt:if %s.Field == HUDAlign
8190                                 Align [2]float32
8191
8192                                 //mt:if %s.Field == HUDOffset
8193                                 Offset [2]float32
8194
8195                                 //mt:if %s.Field == HUDWorldPos
8196                                 WorldPos Pos
8197
8198                                 //mt:if %s.Field == HUDSize
8199                                 Size [2]int32
8200
8201                                 //mt:if %s.Field == HUDZIndex
8202                                 ZIndex int32
8203
8204                                 //mt:if %s.Field == HUDText2
8205                                 Text2 string
8206
8207                                 //mt:if %s.Field == HUDStyle
8208                                 Style HUDStyleFlags
8209                         }))(obj)).Number
8210                         write32(w, uint32(x))
8211                 }
8212         }
8213         if (*(*(struct {
8214                 ID HUDID
8215
8216                 Field HUDField
8217
8218                 //mt:if %s.Field == HUDPos
8219                 Pos [2]float32
8220
8221                 //mt:if %s.Field == HUDName
8222                 Name string
8223
8224                 //mt:if %s.Field == HUDScale
8225                 Scale [2]float32
8226
8227                 //mt:if %s.Field == HUDText
8228                 Text string
8229
8230                 //mt:if %s.Field == HUDNumber
8231                 Number uint32
8232
8233                 //mt:if %s.Field == HUDItem
8234                 Item uint32
8235
8236                 //mt:if %s.Field == HUDDir
8237                 Dir uint32
8238
8239                 //mt:if %s.Field == HUDAlign
8240                 Align [2]float32
8241
8242                 //mt:if %s.Field == HUDOffset
8243                 Offset [2]float32
8244
8245                 //mt:if %s.Field == HUDWorldPos
8246                 WorldPos Pos
8247
8248                 //mt:if %s.Field == HUDSize
8249                 Size [2]int32
8250
8251                 //mt:if %s.Field == HUDZIndex
8252                 ZIndex int32
8253
8254                 //mt:if %s.Field == HUDText2
8255                 Text2 string
8256
8257                 //mt:if %s.Field == HUDStyle
8258                 Style HUDStyleFlags
8259         }))(obj)).Field == HUDItem {
8260                 {
8261                         x := (*(*(struct {
8262                                 ID HUDID
8263
8264                                 Field HUDField
8265
8266                                 //mt:if %s.Field == HUDPos
8267                                 Pos [2]float32
8268
8269                                 //mt:if %s.Field == HUDName
8270                                 Name string
8271
8272                                 //mt:if %s.Field == HUDScale
8273                                 Scale [2]float32
8274
8275                                 //mt:if %s.Field == HUDText
8276                                 Text string
8277
8278                                 //mt:if %s.Field == HUDNumber
8279                                 Number uint32
8280
8281                                 //mt:if %s.Field == HUDItem
8282                                 Item uint32
8283
8284                                 //mt:if %s.Field == HUDDir
8285                                 Dir uint32
8286
8287                                 //mt:if %s.Field == HUDAlign
8288                                 Align [2]float32
8289
8290                                 //mt:if %s.Field == HUDOffset
8291                                 Offset [2]float32
8292
8293                                 //mt:if %s.Field == HUDWorldPos
8294                                 WorldPos Pos
8295
8296                                 //mt:if %s.Field == HUDSize
8297                                 Size [2]int32
8298
8299                                 //mt:if %s.Field == HUDZIndex
8300                                 ZIndex int32
8301
8302                                 //mt:if %s.Field == HUDText2
8303                                 Text2 string
8304
8305                                 //mt:if %s.Field == HUDStyle
8306                                 Style HUDStyleFlags
8307                         }))(obj)).Item
8308                         write32(w, uint32(x))
8309                 }
8310         }
8311         if (*(*(struct {
8312                 ID HUDID
8313
8314                 Field HUDField
8315
8316                 //mt:if %s.Field == HUDPos
8317                 Pos [2]float32
8318
8319                 //mt:if %s.Field == HUDName
8320                 Name string
8321
8322                 //mt:if %s.Field == HUDScale
8323                 Scale [2]float32
8324
8325                 //mt:if %s.Field == HUDText
8326                 Text string
8327
8328                 //mt:if %s.Field == HUDNumber
8329                 Number uint32
8330
8331                 //mt:if %s.Field == HUDItem
8332                 Item uint32
8333
8334                 //mt:if %s.Field == HUDDir
8335                 Dir uint32
8336
8337                 //mt:if %s.Field == HUDAlign
8338                 Align [2]float32
8339
8340                 //mt:if %s.Field == HUDOffset
8341                 Offset [2]float32
8342
8343                 //mt:if %s.Field == HUDWorldPos
8344                 WorldPos Pos
8345
8346                 //mt:if %s.Field == HUDSize
8347                 Size [2]int32
8348
8349                 //mt:if %s.Field == HUDZIndex
8350                 ZIndex int32
8351
8352                 //mt:if %s.Field == HUDText2
8353                 Text2 string
8354
8355                 //mt:if %s.Field == HUDStyle
8356                 Style HUDStyleFlags
8357         }))(obj)).Field == HUDDir {
8358                 {
8359                         x := (*(*(struct {
8360                                 ID HUDID
8361
8362                                 Field HUDField
8363
8364                                 //mt:if %s.Field == HUDPos
8365                                 Pos [2]float32
8366
8367                                 //mt:if %s.Field == HUDName
8368                                 Name string
8369
8370                                 //mt:if %s.Field == HUDScale
8371                                 Scale [2]float32
8372
8373                                 //mt:if %s.Field == HUDText
8374                                 Text string
8375
8376                                 //mt:if %s.Field == HUDNumber
8377                                 Number uint32
8378
8379                                 //mt:if %s.Field == HUDItem
8380                                 Item uint32
8381
8382                                 //mt:if %s.Field == HUDDir
8383                                 Dir uint32
8384
8385                                 //mt:if %s.Field == HUDAlign
8386                                 Align [2]float32
8387
8388                                 //mt:if %s.Field == HUDOffset
8389                                 Offset [2]float32
8390
8391                                 //mt:if %s.Field == HUDWorldPos
8392                                 WorldPos Pos
8393
8394                                 //mt:if %s.Field == HUDSize
8395                                 Size [2]int32
8396
8397                                 //mt:if %s.Field == HUDZIndex
8398                                 ZIndex int32
8399
8400                                 //mt:if %s.Field == HUDText2
8401                                 Text2 string
8402
8403                                 //mt:if %s.Field == HUDStyle
8404                                 Style HUDStyleFlags
8405                         }))(obj)).Dir
8406                         write32(w, uint32(x))
8407                 }
8408         }
8409         if (*(*(struct {
8410                 ID HUDID
8411
8412                 Field HUDField
8413
8414                 //mt:if %s.Field == HUDPos
8415                 Pos [2]float32
8416
8417                 //mt:if %s.Field == HUDName
8418                 Name string
8419
8420                 //mt:if %s.Field == HUDScale
8421                 Scale [2]float32
8422
8423                 //mt:if %s.Field == HUDText
8424                 Text string
8425
8426                 //mt:if %s.Field == HUDNumber
8427                 Number uint32
8428
8429                 //mt:if %s.Field == HUDItem
8430                 Item uint32
8431
8432                 //mt:if %s.Field == HUDDir
8433                 Dir uint32
8434
8435                 //mt:if %s.Field == HUDAlign
8436                 Align [2]float32
8437
8438                 //mt:if %s.Field == HUDOffset
8439                 Offset [2]float32
8440
8441                 //mt:if %s.Field == HUDWorldPos
8442                 WorldPos Pos
8443
8444                 //mt:if %s.Field == HUDSize
8445                 Size [2]int32
8446
8447                 //mt:if %s.Field == HUDZIndex
8448                 ZIndex int32
8449
8450                 //mt:if %s.Field == HUDText2
8451                 Text2 string
8452
8453                 //mt:if %s.Field == HUDStyle
8454                 Style HUDStyleFlags
8455         }))(obj)).Field == HUDAlign {
8456                 for local174 := range (*(*(struct {
8457                         ID HUDID
8458
8459                         Field HUDField
8460
8461                         //mt:if %s.Field == HUDPos
8462                         Pos [2]float32
8463
8464                         //mt:if %s.Field == HUDName
8465                         Name string
8466
8467                         //mt:if %s.Field == HUDScale
8468                         Scale [2]float32
8469
8470                         //mt:if %s.Field == HUDText
8471                         Text string
8472
8473                         //mt:if %s.Field == HUDNumber
8474                         Number uint32
8475
8476                         //mt:if %s.Field == HUDItem
8477                         Item uint32
8478
8479                         //mt:if %s.Field == HUDDir
8480                         Dir uint32
8481
8482                         //mt:if %s.Field == HUDAlign
8483                         Align [2]float32
8484
8485                         //mt:if %s.Field == HUDOffset
8486                         Offset [2]float32
8487
8488                         //mt:if %s.Field == HUDWorldPos
8489                         WorldPos Pos
8490
8491                         //mt:if %s.Field == HUDSize
8492                         Size [2]int32
8493
8494                         //mt:if %s.Field == HUDZIndex
8495                         ZIndex int32
8496
8497                         //mt:if %s.Field == HUDText2
8498                         Text2 string
8499
8500                         //mt:if %s.Field == HUDStyle
8501                         Style HUDStyleFlags
8502                 }))(obj)).Align {
8503                         {
8504                                 x := ((*(*(struct {
8505                                         ID HUDID
8506
8507                                         Field HUDField
8508
8509                                         //mt:if %s.Field == HUDPos
8510                                         Pos [2]float32
8511
8512                                         //mt:if %s.Field == HUDName
8513                                         Name string
8514
8515                                         //mt:if %s.Field == HUDScale
8516                                         Scale [2]float32
8517
8518                                         //mt:if %s.Field == HUDText
8519                                         Text string
8520
8521                                         //mt:if %s.Field == HUDNumber
8522                                         Number uint32
8523
8524                                         //mt:if %s.Field == HUDItem
8525                                         Item uint32
8526
8527                                         //mt:if %s.Field == HUDDir
8528                                         Dir uint32
8529
8530                                         //mt:if %s.Field == HUDAlign
8531                                         Align [2]float32
8532
8533                                         //mt:if %s.Field == HUDOffset
8534                                         Offset [2]float32
8535
8536                                         //mt:if %s.Field == HUDWorldPos
8537                                         WorldPos Pos
8538
8539                                         //mt:if %s.Field == HUDSize
8540                                         Size [2]int32
8541
8542                                         //mt:if %s.Field == HUDZIndex
8543                                         ZIndex int32
8544
8545                                         //mt:if %s.Field == HUDText2
8546                                         Text2 string
8547
8548                                         //mt:if %s.Field == HUDStyle
8549                                         Style HUDStyleFlags
8550                                 }))(obj)).Align)[local174]
8551                                 write32(w, math.Float32bits(x))
8552                         }
8553                 }
8554         }
8555         if (*(*(struct {
8556                 ID HUDID
8557
8558                 Field HUDField
8559
8560                 //mt:if %s.Field == HUDPos
8561                 Pos [2]float32
8562
8563                 //mt:if %s.Field == HUDName
8564                 Name string
8565
8566                 //mt:if %s.Field == HUDScale
8567                 Scale [2]float32
8568
8569                 //mt:if %s.Field == HUDText
8570                 Text string
8571
8572                 //mt:if %s.Field == HUDNumber
8573                 Number uint32
8574
8575                 //mt:if %s.Field == HUDItem
8576                 Item uint32
8577
8578                 //mt:if %s.Field == HUDDir
8579                 Dir uint32
8580
8581                 //mt:if %s.Field == HUDAlign
8582                 Align [2]float32
8583
8584                 //mt:if %s.Field == HUDOffset
8585                 Offset [2]float32
8586
8587                 //mt:if %s.Field == HUDWorldPos
8588                 WorldPos Pos
8589
8590                 //mt:if %s.Field == HUDSize
8591                 Size [2]int32
8592
8593                 //mt:if %s.Field == HUDZIndex
8594                 ZIndex int32
8595
8596                 //mt:if %s.Field == HUDText2
8597                 Text2 string
8598
8599                 //mt:if %s.Field == HUDStyle
8600                 Style HUDStyleFlags
8601         }))(obj)).Field == HUDOffset {
8602                 for local175 := range (*(*(struct {
8603                         ID HUDID
8604
8605                         Field HUDField
8606
8607                         //mt:if %s.Field == HUDPos
8608                         Pos [2]float32
8609
8610                         //mt:if %s.Field == HUDName
8611                         Name string
8612
8613                         //mt:if %s.Field == HUDScale
8614                         Scale [2]float32
8615
8616                         //mt:if %s.Field == HUDText
8617                         Text string
8618
8619                         //mt:if %s.Field == HUDNumber
8620                         Number uint32
8621
8622                         //mt:if %s.Field == HUDItem
8623                         Item uint32
8624
8625                         //mt:if %s.Field == HUDDir
8626                         Dir uint32
8627
8628                         //mt:if %s.Field == HUDAlign
8629                         Align [2]float32
8630
8631                         //mt:if %s.Field == HUDOffset
8632                         Offset [2]float32
8633
8634                         //mt:if %s.Field == HUDWorldPos
8635                         WorldPos Pos
8636
8637                         //mt:if %s.Field == HUDSize
8638                         Size [2]int32
8639
8640                         //mt:if %s.Field == HUDZIndex
8641                         ZIndex int32
8642
8643                         //mt:if %s.Field == HUDText2
8644                         Text2 string
8645
8646                         //mt:if %s.Field == HUDStyle
8647                         Style HUDStyleFlags
8648                 }))(obj)).Offset {
8649                         {
8650                                 x := ((*(*(struct {
8651                                         ID HUDID
8652
8653                                         Field HUDField
8654
8655                                         //mt:if %s.Field == HUDPos
8656                                         Pos [2]float32
8657
8658                                         //mt:if %s.Field == HUDName
8659                                         Name string
8660
8661                                         //mt:if %s.Field == HUDScale
8662                                         Scale [2]float32
8663
8664                                         //mt:if %s.Field == HUDText
8665                                         Text string
8666
8667                                         //mt:if %s.Field == HUDNumber
8668                                         Number uint32
8669
8670                                         //mt:if %s.Field == HUDItem
8671                                         Item uint32
8672
8673                                         //mt:if %s.Field == HUDDir
8674                                         Dir uint32
8675
8676                                         //mt:if %s.Field == HUDAlign
8677                                         Align [2]float32
8678
8679                                         //mt:if %s.Field == HUDOffset
8680                                         Offset [2]float32
8681
8682                                         //mt:if %s.Field == HUDWorldPos
8683                                         WorldPos Pos
8684
8685                                         //mt:if %s.Field == HUDSize
8686                                         Size [2]int32
8687
8688                                         //mt:if %s.Field == HUDZIndex
8689                                         ZIndex int32
8690
8691                                         //mt:if %s.Field == HUDText2
8692                                         Text2 string
8693
8694                                         //mt:if %s.Field == HUDStyle
8695                                         Style HUDStyleFlags
8696                                 }))(obj)).Offset)[local175]
8697                                 write32(w, math.Float32bits(x))
8698                         }
8699                 }
8700         }
8701         if (*(*(struct {
8702                 ID HUDID
8703
8704                 Field HUDField
8705
8706                 //mt:if %s.Field == HUDPos
8707                 Pos [2]float32
8708
8709                 //mt:if %s.Field == HUDName
8710                 Name string
8711
8712                 //mt:if %s.Field == HUDScale
8713                 Scale [2]float32
8714
8715                 //mt:if %s.Field == HUDText
8716                 Text string
8717
8718                 //mt:if %s.Field == HUDNumber
8719                 Number uint32
8720
8721                 //mt:if %s.Field == HUDItem
8722                 Item uint32
8723
8724                 //mt:if %s.Field == HUDDir
8725                 Dir uint32
8726
8727                 //mt:if %s.Field == HUDAlign
8728                 Align [2]float32
8729
8730                 //mt:if %s.Field == HUDOffset
8731                 Offset [2]float32
8732
8733                 //mt:if %s.Field == HUDWorldPos
8734                 WorldPos Pos
8735
8736                 //mt:if %s.Field == HUDSize
8737                 Size [2]int32
8738
8739                 //mt:if %s.Field == HUDZIndex
8740                 ZIndex int32
8741
8742                 //mt:if %s.Field == HUDText2
8743                 Text2 string
8744
8745                 //mt:if %s.Field == HUDStyle
8746                 Style HUDStyleFlags
8747         }))(obj)).Field == HUDWorldPos {
8748                 if err := pcall(func() {
8749                         ((*(*(struct {
8750                                 ID HUDID
8751
8752                                 Field HUDField
8753
8754                                 //mt:if %s.Field == HUDPos
8755                                 Pos [2]float32
8756
8757                                 //mt:if %s.Field == HUDName
8758                                 Name string
8759
8760                                 //mt:if %s.Field == HUDScale
8761                                 Scale [2]float32
8762
8763                                 //mt:if %s.Field == HUDText
8764                                 Text string
8765
8766                                 //mt:if %s.Field == HUDNumber
8767                                 Number uint32
8768
8769                                 //mt:if %s.Field == HUDItem
8770                                 Item uint32
8771
8772                                 //mt:if %s.Field == HUDDir
8773                                 Dir uint32
8774
8775                                 //mt:if %s.Field == HUDAlign
8776                                 Align [2]float32
8777
8778                                 //mt:if %s.Field == HUDOffset
8779                                 Offset [2]float32
8780
8781                                 //mt:if %s.Field == HUDWorldPos
8782                                 WorldPos Pos
8783
8784                                 //mt:if %s.Field == HUDSize
8785                                 Size [2]int32
8786
8787                                 //mt:if %s.Field == HUDZIndex
8788                                 ZIndex int32
8789
8790                                 //mt:if %s.Field == HUDText2
8791                                 Text2 string
8792
8793                                 //mt:if %s.Field == HUDStyle
8794                                 Style HUDStyleFlags
8795                         }))(obj)).WorldPos).serialize(w)
8796                 }); err != nil {
8797                         if err == io.EOF {
8798                                 chk(io.EOF)
8799                         }
8800                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
8801                 }
8802         }
8803         if (*(*(struct {
8804                 ID HUDID
8805
8806                 Field HUDField
8807
8808                 //mt:if %s.Field == HUDPos
8809                 Pos [2]float32
8810
8811                 //mt:if %s.Field == HUDName
8812                 Name string
8813
8814                 //mt:if %s.Field == HUDScale
8815                 Scale [2]float32
8816
8817                 //mt:if %s.Field == HUDText
8818                 Text string
8819
8820                 //mt:if %s.Field == HUDNumber
8821                 Number uint32
8822
8823                 //mt:if %s.Field == HUDItem
8824                 Item uint32
8825
8826                 //mt:if %s.Field == HUDDir
8827                 Dir uint32
8828
8829                 //mt:if %s.Field == HUDAlign
8830                 Align [2]float32
8831
8832                 //mt:if %s.Field == HUDOffset
8833                 Offset [2]float32
8834
8835                 //mt:if %s.Field == HUDWorldPos
8836                 WorldPos Pos
8837
8838                 //mt:if %s.Field == HUDSize
8839                 Size [2]int32
8840
8841                 //mt:if %s.Field == HUDZIndex
8842                 ZIndex int32
8843
8844                 //mt:if %s.Field == HUDText2
8845                 Text2 string
8846
8847                 //mt:if %s.Field == HUDStyle
8848                 Style HUDStyleFlags
8849         }))(obj)).Field == HUDSize {
8850                 for local176 := range (*(*(struct {
8851                         ID HUDID
8852
8853                         Field HUDField
8854
8855                         //mt:if %s.Field == HUDPos
8856                         Pos [2]float32
8857
8858                         //mt:if %s.Field == HUDName
8859                         Name string
8860
8861                         //mt:if %s.Field == HUDScale
8862                         Scale [2]float32
8863
8864                         //mt:if %s.Field == HUDText
8865                         Text string
8866
8867                         //mt:if %s.Field == HUDNumber
8868                         Number uint32
8869
8870                         //mt:if %s.Field == HUDItem
8871                         Item uint32
8872
8873                         //mt:if %s.Field == HUDDir
8874                         Dir uint32
8875
8876                         //mt:if %s.Field == HUDAlign
8877                         Align [2]float32
8878
8879                         //mt:if %s.Field == HUDOffset
8880                         Offset [2]float32
8881
8882                         //mt:if %s.Field == HUDWorldPos
8883                         WorldPos Pos
8884
8885                         //mt:if %s.Field == HUDSize
8886                         Size [2]int32
8887
8888                         //mt:if %s.Field == HUDZIndex
8889                         ZIndex int32
8890
8891                         //mt:if %s.Field == HUDText2
8892                         Text2 string
8893
8894                         //mt:if %s.Field == HUDStyle
8895                         Style HUDStyleFlags
8896                 }))(obj)).Size {
8897                         {
8898                                 x := ((*(*(struct {
8899                                         ID HUDID
8900
8901                                         Field HUDField
8902
8903                                         //mt:if %s.Field == HUDPos
8904                                         Pos [2]float32
8905
8906                                         //mt:if %s.Field == HUDName
8907                                         Name string
8908
8909                                         //mt:if %s.Field == HUDScale
8910                                         Scale [2]float32
8911
8912                                         //mt:if %s.Field == HUDText
8913                                         Text string
8914
8915                                         //mt:if %s.Field == HUDNumber
8916                                         Number uint32
8917
8918                                         //mt:if %s.Field == HUDItem
8919                                         Item uint32
8920
8921                                         //mt:if %s.Field == HUDDir
8922                                         Dir uint32
8923
8924                                         //mt:if %s.Field == HUDAlign
8925                                         Align [2]float32
8926
8927                                         //mt:if %s.Field == HUDOffset
8928                                         Offset [2]float32
8929
8930                                         //mt:if %s.Field == HUDWorldPos
8931                                         WorldPos Pos
8932
8933                                         //mt:if %s.Field == HUDSize
8934                                         Size [2]int32
8935
8936                                         //mt:if %s.Field == HUDZIndex
8937                                         ZIndex int32
8938
8939                                         //mt:if %s.Field == HUDText2
8940                                         Text2 string
8941
8942                                         //mt:if %s.Field == HUDStyle
8943                                         Style HUDStyleFlags
8944                                 }))(obj)).Size)[local176]
8945                                 write32(w, uint32(x))
8946                         }
8947                 }
8948         }
8949         if (*(*(struct {
8950                 ID HUDID
8951
8952                 Field HUDField
8953
8954                 //mt:if %s.Field == HUDPos
8955                 Pos [2]float32
8956
8957                 //mt:if %s.Field == HUDName
8958                 Name string
8959
8960                 //mt:if %s.Field == HUDScale
8961                 Scale [2]float32
8962
8963                 //mt:if %s.Field == HUDText
8964                 Text string
8965
8966                 //mt:if %s.Field == HUDNumber
8967                 Number uint32
8968
8969                 //mt:if %s.Field == HUDItem
8970                 Item uint32
8971
8972                 //mt:if %s.Field == HUDDir
8973                 Dir uint32
8974
8975                 //mt:if %s.Field == HUDAlign
8976                 Align [2]float32
8977
8978                 //mt:if %s.Field == HUDOffset
8979                 Offset [2]float32
8980
8981                 //mt:if %s.Field == HUDWorldPos
8982                 WorldPos Pos
8983
8984                 //mt:if %s.Field == HUDSize
8985                 Size [2]int32
8986
8987                 //mt:if %s.Field == HUDZIndex
8988                 ZIndex int32
8989
8990                 //mt:if %s.Field == HUDText2
8991                 Text2 string
8992
8993                 //mt:if %s.Field == HUDStyle
8994                 Style HUDStyleFlags
8995         }))(obj)).Field == HUDZIndex {
8996                 {
8997                         x := (*(*(struct {
8998                                 ID HUDID
8999
9000                                 Field HUDField
9001
9002                                 //mt:if %s.Field == HUDPos
9003                                 Pos [2]float32
9004
9005                                 //mt:if %s.Field == HUDName
9006                                 Name string
9007
9008                                 //mt:if %s.Field == HUDScale
9009                                 Scale [2]float32
9010
9011                                 //mt:if %s.Field == HUDText
9012                                 Text string
9013
9014                                 //mt:if %s.Field == HUDNumber
9015                                 Number uint32
9016
9017                                 //mt:if %s.Field == HUDItem
9018                                 Item uint32
9019
9020                                 //mt:if %s.Field == HUDDir
9021                                 Dir uint32
9022
9023                                 //mt:if %s.Field == HUDAlign
9024                                 Align [2]float32
9025
9026                                 //mt:if %s.Field == HUDOffset
9027                                 Offset [2]float32
9028
9029                                 //mt:if %s.Field == HUDWorldPos
9030                                 WorldPos Pos
9031
9032                                 //mt:if %s.Field == HUDSize
9033                                 Size [2]int32
9034
9035                                 //mt:if %s.Field == HUDZIndex
9036                                 ZIndex int32
9037
9038                                 //mt:if %s.Field == HUDText2
9039                                 Text2 string
9040
9041                                 //mt:if %s.Field == HUDStyle
9042                                 Style HUDStyleFlags
9043                         }))(obj)).ZIndex
9044                         write32(w, uint32(x))
9045                 }
9046         }
9047         if (*(*(struct {
9048                 ID HUDID
9049
9050                 Field HUDField
9051
9052                 //mt:if %s.Field == HUDPos
9053                 Pos [2]float32
9054
9055                 //mt:if %s.Field == HUDName
9056                 Name string
9057
9058                 //mt:if %s.Field == HUDScale
9059                 Scale [2]float32
9060
9061                 //mt:if %s.Field == HUDText
9062                 Text string
9063
9064                 //mt:if %s.Field == HUDNumber
9065                 Number uint32
9066
9067                 //mt:if %s.Field == HUDItem
9068                 Item uint32
9069
9070                 //mt:if %s.Field == HUDDir
9071                 Dir uint32
9072
9073                 //mt:if %s.Field == HUDAlign
9074                 Align [2]float32
9075
9076                 //mt:if %s.Field == HUDOffset
9077                 Offset [2]float32
9078
9079                 //mt:if %s.Field == HUDWorldPos
9080                 WorldPos Pos
9081
9082                 //mt:if %s.Field == HUDSize
9083                 Size [2]int32
9084
9085                 //mt:if %s.Field == HUDZIndex
9086                 ZIndex int32
9087
9088                 //mt:if %s.Field == HUDText2
9089                 Text2 string
9090
9091                 //mt:if %s.Field == HUDStyle
9092                 Style HUDStyleFlags
9093         }))(obj)).Field == HUDText2 {
9094                 if len(([]byte((*(*(struct {
9095                         ID HUDID
9096
9097                         Field HUDField
9098
9099                         //mt:if %s.Field == HUDPos
9100                         Pos [2]float32
9101
9102                         //mt:if %s.Field == HUDName
9103                         Name string
9104
9105                         //mt:if %s.Field == HUDScale
9106                         Scale [2]float32
9107
9108                         //mt:if %s.Field == HUDText
9109                         Text string
9110
9111                         //mt:if %s.Field == HUDNumber
9112                         Number uint32
9113
9114                         //mt:if %s.Field == HUDItem
9115                         Item uint32
9116
9117                         //mt:if %s.Field == HUDDir
9118                         Dir uint32
9119
9120                         //mt:if %s.Field == HUDAlign
9121                         Align [2]float32
9122
9123                         //mt:if %s.Field == HUDOffset
9124                         Offset [2]float32
9125
9126                         //mt:if %s.Field == HUDWorldPos
9127                         WorldPos Pos
9128
9129                         //mt:if %s.Field == HUDSize
9130                         Size [2]int32
9131
9132                         //mt:if %s.Field == HUDZIndex
9133                         ZIndex int32
9134
9135                         //mt:if %s.Field == HUDText2
9136                         Text2 string
9137
9138                         //mt:if %s.Field == HUDStyle
9139                         Style HUDStyleFlags
9140                 }))(obj)).Text2))) > math.MaxUint16 {
9141                         chk(ErrTooLong)
9142                 }
9143                 {
9144                         x := uint16(len(([]byte((*(*(struct {
9145                                 ID HUDID
9146
9147                                 Field HUDField
9148
9149                                 //mt:if %s.Field == HUDPos
9150                                 Pos [2]float32
9151
9152                                 //mt:if %s.Field == HUDName
9153                                 Name string
9154
9155                                 //mt:if %s.Field == HUDScale
9156                                 Scale [2]float32
9157
9158                                 //mt:if %s.Field == HUDText
9159                                 Text string
9160
9161                                 //mt:if %s.Field == HUDNumber
9162                                 Number uint32
9163
9164                                 //mt:if %s.Field == HUDItem
9165                                 Item uint32
9166
9167                                 //mt:if %s.Field == HUDDir
9168                                 Dir uint32
9169
9170                                 //mt:if %s.Field == HUDAlign
9171                                 Align [2]float32
9172
9173                                 //mt:if %s.Field == HUDOffset
9174                                 Offset [2]float32
9175
9176                                 //mt:if %s.Field == HUDWorldPos
9177                                 WorldPos Pos
9178
9179                                 //mt:if %s.Field == HUDSize
9180                                 Size [2]int32
9181
9182                                 //mt:if %s.Field == HUDZIndex
9183                                 ZIndex int32
9184
9185                                 //mt:if %s.Field == HUDText2
9186                                 Text2 string
9187
9188                                 //mt:if %s.Field == HUDStyle
9189                                 Style HUDStyleFlags
9190                         }))(obj)).Text2))))
9191                         write16(w, uint16(x))
9192                 }
9193                 {
9194                         _, err := w.Write(([]byte((*(*(struct {
9195                                 ID HUDID
9196
9197                                 Field HUDField
9198
9199                                 //mt:if %s.Field == HUDPos
9200                                 Pos [2]float32
9201
9202                                 //mt:if %s.Field == HUDName
9203                                 Name string
9204
9205                                 //mt:if %s.Field == HUDScale
9206                                 Scale [2]float32
9207
9208                                 //mt:if %s.Field == HUDText
9209                                 Text string
9210
9211                                 //mt:if %s.Field == HUDNumber
9212                                 Number uint32
9213
9214                                 //mt:if %s.Field == HUDItem
9215                                 Item uint32
9216
9217                                 //mt:if %s.Field == HUDDir
9218                                 Dir uint32
9219
9220                                 //mt:if %s.Field == HUDAlign
9221                                 Align [2]float32
9222
9223                                 //mt:if %s.Field == HUDOffset
9224                                 Offset [2]float32
9225
9226                                 //mt:if %s.Field == HUDWorldPos
9227                                 WorldPos Pos
9228
9229                                 //mt:if %s.Field == HUDSize
9230                                 Size [2]int32
9231
9232                                 //mt:if %s.Field == HUDZIndex
9233                                 ZIndex int32
9234
9235                                 //mt:if %s.Field == HUDText2
9236                                 Text2 string
9237
9238                                 //mt:if %s.Field == HUDStyle
9239                                 Style HUDStyleFlags
9240                         }))(obj)).Text2))[:])
9241                         chk(err)
9242                 }
9243         }
9244         if (*(*(struct {
9245                 ID HUDID
9246
9247                 Field HUDField
9248
9249                 //mt:if %s.Field == HUDPos
9250                 Pos [2]float32
9251
9252                 //mt:if %s.Field == HUDName
9253                 Name string
9254
9255                 //mt:if %s.Field == HUDScale
9256                 Scale [2]float32
9257
9258                 //mt:if %s.Field == HUDText
9259                 Text string
9260
9261                 //mt:if %s.Field == HUDNumber
9262                 Number uint32
9263
9264                 //mt:if %s.Field == HUDItem
9265                 Item uint32
9266
9267                 //mt:if %s.Field == HUDDir
9268                 Dir uint32
9269
9270                 //mt:if %s.Field == HUDAlign
9271                 Align [2]float32
9272
9273                 //mt:if %s.Field == HUDOffset
9274                 Offset [2]float32
9275
9276                 //mt:if %s.Field == HUDWorldPos
9277                 WorldPos Pos
9278
9279                 //mt:if %s.Field == HUDSize
9280                 Size [2]int32
9281
9282                 //mt:if %s.Field == HUDZIndex
9283                 ZIndex int32
9284
9285                 //mt:if %s.Field == HUDText2
9286                 Text2 string
9287
9288                 //mt:if %s.Field == HUDStyle
9289                 Style HUDStyleFlags
9290         }))(obj)).Field == HUDStyle {
9291                 if err := pcall(func() {
9292                         ((*(*(struct {
9293                                 ID HUDID
9294
9295                                 Field HUDField
9296
9297                                 //mt:if %s.Field == HUDPos
9298                                 Pos [2]float32
9299
9300                                 //mt:if %s.Field == HUDName
9301                                 Name string
9302
9303                                 //mt:if %s.Field == HUDScale
9304                                 Scale [2]float32
9305
9306                                 //mt:if %s.Field == HUDText
9307                                 Text string
9308
9309                                 //mt:if %s.Field == HUDNumber
9310                                 Number uint32
9311
9312                                 //mt:if %s.Field == HUDItem
9313                                 Item uint32
9314
9315                                 //mt:if %s.Field == HUDDir
9316                                 Dir uint32
9317
9318                                 //mt:if %s.Field == HUDAlign
9319                                 Align [2]float32
9320
9321                                 //mt:if %s.Field == HUDOffset
9322                                 Offset [2]float32
9323
9324                                 //mt:if %s.Field == HUDWorldPos
9325                                 WorldPos Pos
9326
9327                                 //mt:if %s.Field == HUDSize
9328                                 Size [2]int32
9329
9330                                 //mt:if %s.Field == HUDZIndex
9331                                 ZIndex int32
9332
9333                                 //mt:if %s.Field == HUDText2
9334                                 Text2 string
9335
9336                                 //mt:if %s.Field == HUDStyle
9337                                 Style HUDStyleFlags
9338                         }))(obj)).Style).serialize(w)
9339                 }); err != nil {
9340                         if err == io.EOF {
9341                                 chk(io.EOF)
9342                         }
9343                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
9344                 }
9345         }
9346 }
9347
9348 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
9349         if err := pcall(func() {
9350                 ((*(*(struct {
9351                         ID HUDID
9352
9353                         Field HUDField
9354
9355                         //mt:if %s.Field == HUDPos
9356                         Pos [2]float32
9357
9358                         //mt:if %s.Field == HUDName
9359                         Name string
9360
9361                         //mt:if %s.Field == HUDScale
9362                         Scale [2]float32
9363
9364                         //mt:if %s.Field == HUDText
9365                         Text string
9366
9367                         //mt:if %s.Field == HUDNumber
9368                         Number uint32
9369
9370                         //mt:if %s.Field == HUDItem
9371                         Item uint32
9372
9373                         //mt:if %s.Field == HUDDir
9374                         Dir uint32
9375
9376                         //mt:if %s.Field == HUDAlign
9377                         Align [2]float32
9378
9379                         //mt:if %s.Field == HUDOffset
9380                         Offset [2]float32
9381
9382                         //mt:if %s.Field == HUDWorldPos
9383                         WorldPos Pos
9384
9385                         //mt:if %s.Field == HUDSize
9386                         Size [2]int32
9387
9388                         //mt:if %s.Field == HUDZIndex
9389                         ZIndex int32
9390
9391                         //mt:if %s.Field == HUDText2
9392                         Text2 string
9393
9394                         //mt:if %s.Field == HUDStyle
9395                         Style HUDStyleFlags
9396                 }))(obj)).ID).deserialize(r)
9397         }); err != nil {
9398                 if err == io.EOF {
9399                         chk(io.EOF)
9400                 }
9401                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
9402         }
9403         if err := pcall(func() {
9404                 ((*(*(struct {
9405                         ID HUDID
9406
9407                         Field HUDField
9408
9409                         //mt:if %s.Field == HUDPos
9410                         Pos [2]float32
9411
9412                         //mt:if %s.Field == HUDName
9413                         Name string
9414
9415                         //mt:if %s.Field == HUDScale
9416                         Scale [2]float32
9417
9418                         //mt:if %s.Field == HUDText
9419                         Text string
9420
9421                         //mt:if %s.Field == HUDNumber
9422                         Number uint32
9423
9424                         //mt:if %s.Field == HUDItem
9425                         Item uint32
9426
9427                         //mt:if %s.Field == HUDDir
9428                         Dir uint32
9429
9430                         //mt:if %s.Field == HUDAlign
9431                         Align [2]float32
9432
9433                         //mt:if %s.Field == HUDOffset
9434                         Offset [2]float32
9435
9436                         //mt:if %s.Field == HUDWorldPos
9437                         WorldPos Pos
9438
9439                         //mt:if %s.Field == HUDSize
9440                         Size [2]int32
9441
9442                         //mt:if %s.Field == HUDZIndex
9443                         ZIndex int32
9444
9445                         //mt:if %s.Field == HUDText2
9446                         Text2 string
9447
9448                         //mt:if %s.Field == HUDStyle
9449                         Style HUDStyleFlags
9450                 }))(obj)).Field).deserialize(r)
9451         }); err != nil {
9452                 if err == io.EOF {
9453                         chk(io.EOF)
9454                 }
9455                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
9456         }
9457         if !((*(*(struct {
9458                 ID HUDID
9459
9460                 Field HUDField
9461
9462                 //mt:if %s.Field == HUDPos
9463                 Pos [2]float32
9464
9465                 //mt:if %s.Field == HUDName
9466                 Name string
9467
9468                 //mt:if %s.Field == HUDScale
9469                 Scale [2]float32
9470
9471                 //mt:if %s.Field == HUDText
9472                 Text string
9473
9474                 //mt:if %s.Field == HUDNumber
9475                 Number uint32
9476
9477                 //mt:if %s.Field == HUDItem
9478                 Item uint32
9479
9480                 //mt:if %s.Field == HUDDir
9481                 Dir uint32
9482
9483                 //mt:if %s.Field == HUDAlign
9484                 Align [2]float32
9485
9486                 //mt:if %s.Field == HUDOffset
9487                 Offset [2]float32
9488
9489                 //mt:if %s.Field == HUDWorldPos
9490                 WorldPos Pos
9491
9492                 //mt:if %s.Field == HUDSize
9493                 Size [2]int32
9494
9495                 //mt:if %s.Field == HUDZIndex
9496                 ZIndex int32
9497
9498                 //mt:if %s.Field == HUDText2
9499                 Text2 string
9500
9501                 //mt:if %s.Field == HUDStyle
9502                 Style HUDStyleFlags
9503         }))(obj)).Field < hudMax) {
9504                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9505         }
9506         if (*(*(struct {
9507                 ID HUDID
9508
9509                 Field HUDField
9510
9511                 //mt:if %s.Field == HUDPos
9512                 Pos [2]float32
9513
9514                 //mt:if %s.Field == HUDName
9515                 Name string
9516
9517                 //mt:if %s.Field == HUDScale
9518                 Scale [2]float32
9519
9520                 //mt:if %s.Field == HUDText
9521                 Text string
9522
9523                 //mt:if %s.Field == HUDNumber
9524                 Number uint32
9525
9526                 //mt:if %s.Field == HUDItem
9527                 Item uint32
9528
9529                 //mt:if %s.Field == HUDDir
9530                 Dir uint32
9531
9532                 //mt:if %s.Field == HUDAlign
9533                 Align [2]float32
9534
9535                 //mt:if %s.Field == HUDOffset
9536                 Offset [2]float32
9537
9538                 //mt:if %s.Field == HUDWorldPos
9539                 WorldPos Pos
9540
9541                 //mt:if %s.Field == HUDSize
9542                 Size [2]int32
9543
9544                 //mt:if %s.Field == HUDZIndex
9545                 ZIndex int32
9546
9547                 //mt:if %s.Field == HUDText2
9548                 Text2 string
9549
9550                 //mt:if %s.Field == HUDStyle
9551                 Style HUDStyleFlags
9552         }))(obj)).Field == HUDPos {
9553                 for local177 := range (*(*(struct {
9554                         ID HUDID
9555
9556                         Field HUDField
9557
9558                         //mt:if %s.Field == HUDPos
9559                         Pos [2]float32
9560
9561                         //mt:if %s.Field == HUDName
9562                         Name string
9563
9564                         //mt:if %s.Field == HUDScale
9565                         Scale [2]float32
9566
9567                         //mt:if %s.Field == HUDText
9568                         Text string
9569
9570                         //mt:if %s.Field == HUDNumber
9571                         Number uint32
9572
9573                         //mt:if %s.Field == HUDItem
9574                         Item uint32
9575
9576                         //mt:if %s.Field == HUDDir
9577                         Dir uint32
9578
9579                         //mt:if %s.Field == HUDAlign
9580                         Align [2]float32
9581
9582                         //mt:if %s.Field == HUDOffset
9583                         Offset [2]float32
9584
9585                         //mt:if %s.Field == HUDWorldPos
9586                         WorldPos Pos
9587
9588                         //mt:if %s.Field == HUDSize
9589                         Size [2]int32
9590
9591                         //mt:if %s.Field == HUDZIndex
9592                         ZIndex int32
9593
9594                         //mt:if %s.Field == HUDText2
9595                         Text2 string
9596
9597                         //mt:if %s.Field == HUDStyle
9598                         Style HUDStyleFlags
9599                 }))(obj)).Pos {
9600                         {
9601                                 p := &((*(*(struct {
9602                                         ID HUDID
9603
9604                                         Field HUDField
9605
9606                                         //mt:if %s.Field == HUDPos
9607                                         Pos [2]float32
9608
9609                                         //mt:if %s.Field == HUDName
9610                                         Name string
9611
9612                                         //mt:if %s.Field == HUDScale
9613                                         Scale [2]float32
9614
9615                                         //mt:if %s.Field == HUDText
9616                                         Text string
9617
9618                                         //mt:if %s.Field == HUDNumber
9619                                         Number uint32
9620
9621                                         //mt:if %s.Field == HUDItem
9622                                         Item uint32
9623
9624                                         //mt:if %s.Field == HUDDir
9625                                         Dir uint32
9626
9627                                         //mt:if %s.Field == HUDAlign
9628                                         Align [2]float32
9629
9630                                         //mt:if %s.Field == HUDOffset
9631                                         Offset [2]float32
9632
9633                                         //mt:if %s.Field == HUDWorldPos
9634                                         WorldPos Pos
9635
9636                                         //mt:if %s.Field == HUDSize
9637                                         Size [2]int32
9638
9639                                         //mt:if %s.Field == HUDZIndex
9640                                         ZIndex int32
9641
9642                                         //mt:if %s.Field == HUDText2
9643                                         Text2 string
9644
9645                                         //mt:if %s.Field == HUDStyle
9646                                         Style HUDStyleFlags
9647                                 }))(obj)).Pos)[local177]
9648                                 *p = math.Float32frombits(read32(r))
9649                         }
9650                 }
9651         }
9652         if (*(*(struct {
9653                 ID HUDID
9654
9655                 Field HUDField
9656
9657                 //mt:if %s.Field == HUDPos
9658                 Pos [2]float32
9659
9660                 //mt:if %s.Field == HUDName
9661                 Name string
9662
9663                 //mt:if %s.Field == HUDScale
9664                 Scale [2]float32
9665
9666                 //mt:if %s.Field == HUDText
9667                 Text string
9668
9669                 //mt:if %s.Field == HUDNumber
9670                 Number uint32
9671
9672                 //mt:if %s.Field == HUDItem
9673                 Item uint32
9674
9675                 //mt:if %s.Field == HUDDir
9676                 Dir uint32
9677
9678                 //mt:if %s.Field == HUDAlign
9679                 Align [2]float32
9680
9681                 //mt:if %s.Field == HUDOffset
9682                 Offset [2]float32
9683
9684                 //mt:if %s.Field == HUDWorldPos
9685                 WorldPos Pos
9686
9687                 //mt:if %s.Field == HUDSize
9688                 Size [2]int32
9689
9690                 //mt:if %s.Field == HUDZIndex
9691                 ZIndex int32
9692
9693                 //mt:if %s.Field == HUDText2
9694                 Text2 string
9695
9696                 //mt:if %s.Field == HUDStyle
9697                 Style HUDStyleFlags
9698         }))(obj)).Field == HUDName {
9699                 var local178 []uint8
9700                 var local179 uint16
9701                 {
9702                         p := &local179
9703                         *p = read16(r)
9704                 }
9705                 (local178) = make([]uint8, local179)
9706                 {
9707                         _, err := io.ReadFull(r, (local178)[:])
9708                         chk(err)
9709                 }
9710                 ((*(*(struct {
9711                         ID HUDID
9712
9713                         Field HUDField
9714
9715                         //mt:if %s.Field == HUDPos
9716                         Pos [2]float32
9717
9718                         //mt:if %s.Field == HUDName
9719                         Name string
9720
9721                         //mt:if %s.Field == HUDScale
9722                         Scale [2]float32
9723
9724                         //mt:if %s.Field == HUDText
9725                         Text string
9726
9727                         //mt:if %s.Field == HUDNumber
9728                         Number uint32
9729
9730                         //mt:if %s.Field == HUDItem
9731                         Item uint32
9732
9733                         //mt:if %s.Field == HUDDir
9734                         Dir uint32
9735
9736                         //mt:if %s.Field == HUDAlign
9737                         Align [2]float32
9738
9739                         //mt:if %s.Field == HUDOffset
9740                         Offset [2]float32
9741
9742                         //mt:if %s.Field == HUDWorldPos
9743                         WorldPos Pos
9744
9745                         //mt:if %s.Field == HUDSize
9746                         Size [2]int32
9747
9748                         //mt:if %s.Field == HUDZIndex
9749                         ZIndex int32
9750
9751                         //mt:if %s.Field == HUDText2
9752                         Text2 string
9753
9754                         //mt:if %s.Field == HUDStyle
9755                         Style HUDStyleFlags
9756                 }))(obj)).Name) = string(local178)
9757         }
9758         if (*(*(struct {
9759                 ID HUDID
9760
9761                 Field HUDField
9762
9763                 //mt:if %s.Field == HUDPos
9764                 Pos [2]float32
9765
9766                 //mt:if %s.Field == HUDName
9767                 Name string
9768
9769                 //mt:if %s.Field == HUDScale
9770                 Scale [2]float32
9771
9772                 //mt:if %s.Field == HUDText
9773                 Text string
9774
9775                 //mt:if %s.Field == HUDNumber
9776                 Number uint32
9777
9778                 //mt:if %s.Field == HUDItem
9779                 Item uint32
9780
9781                 //mt:if %s.Field == HUDDir
9782                 Dir uint32
9783
9784                 //mt:if %s.Field == HUDAlign
9785                 Align [2]float32
9786
9787                 //mt:if %s.Field == HUDOffset
9788                 Offset [2]float32
9789
9790                 //mt:if %s.Field == HUDWorldPos
9791                 WorldPos Pos
9792
9793                 //mt:if %s.Field == HUDSize
9794                 Size [2]int32
9795
9796                 //mt:if %s.Field == HUDZIndex
9797                 ZIndex int32
9798
9799                 //mt:if %s.Field == HUDText2
9800                 Text2 string
9801
9802                 //mt:if %s.Field == HUDStyle
9803                 Style HUDStyleFlags
9804         }))(obj)).Field == HUDScale {
9805                 for local180 := range (*(*(struct {
9806                         ID HUDID
9807
9808                         Field HUDField
9809
9810                         //mt:if %s.Field == HUDPos
9811                         Pos [2]float32
9812
9813                         //mt:if %s.Field == HUDName
9814                         Name string
9815
9816                         //mt:if %s.Field == HUDScale
9817                         Scale [2]float32
9818
9819                         //mt:if %s.Field == HUDText
9820                         Text string
9821
9822                         //mt:if %s.Field == HUDNumber
9823                         Number uint32
9824
9825                         //mt:if %s.Field == HUDItem
9826                         Item uint32
9827
9828                         //mt:if %s.Field == HUDDir
9829                         Dir uint32
9830
9831                         //mt:if %s.Field == HUDAlign
9832                         Align [2]float32
9833
9834                         //mt:if %s.Field == HUDOffset
9835                         Offset [2]float32
9836
9837                         //mt:if %s.Field == HUDWorldPos
9838                         WorldPos Pos
9839
9840                         //mt:if %s.Field == HUDSize
9841                         Size [2]int32
9842
9843                         //mt:if %s.Field == HUDZIndex
9844                         ZIndex int32
9845
9846                         //mt:if %s.Field == HUDText2
9847                         Text2 string
9848
9849                         //mt:if %s.Field == HUDStyle
9850                         Style HUDStyleFlags
9851                 }))(obj)).Scale {
9852                         {
9853                                 p := &((*(*(struct {
9854                                         ID HUDID
9855
9856                                         Field HUDField
9857
9858                                         //mt:if %s.Field == HUDPos
9859                                         Pos [2]float32
9860
9861                                         //mt:if %s.Field == HUDName
9862                                         Name string
9863
9864                                         //mt:if %s.Field == HUDScale
9865                                         Scale [2]float32
9866
9867                                         //mt:if %s.Field == HUDText
9868                                         Text string
9869
9870                                         //mt:if %s.Field == HUDNumber
9871                                         Number uint32
9872
9873                                         //mt:if %s.Field == HUDItem
9874                                         Item uint32
9875
9876                                         //mt:if %s.Field == HUDDir
9877                                         Dir uint32
9878
9879                                         //mt:if %s.Field == HUDAlign
9880                                         Align [2]float32
9881
9882                                         //mt:if %s.Field == HUDOffset
9883                                         Offset [2]float32
9884
9885                                         //mt:if %s.Field == HUDWorldPos
9886                                         WorldPos Pos
9887
9888                                         //mt:if %s.Field == HUDSize
9889                                         Size [2]int32
9890
9891                                         //mt:if %s.Field == HUDZIndex
9892                                         ZIndex int32
9893
9894                                         //mt:if %s.Field == HUDText2
9895                                         Text2 string
9896
9897                                         //mt:if %s.Field == HUDStyle
9898                                         Style HUDStyleFlags
9899                                 }))(obj)).Scale)[local180]
9900                                 *p = math.Float32frombits(read32(r))
9901                         }
9902                 }
9903         }
9904         if (*(*(struct {
9905                 ID HUDID
9906
9907                 Field HUDField
9908
9909                 //mt:if %s.Field == HUDPos
9910                 Pos [2]float32
9911
9912                 //mt:if %s.Field == HUDName
9913                 Name string
9914
9915                 //mt:if %s.Field == HUDScale
9916                 Scale [2]float32
9917
9918                 //mt:if %s.Field == HUDText
9919                 Text string
9920
9921                 //mt:if %s.Field == HUDNumber
9922                 Number uint32
9923
9924                 //mt:if %s.Field == HUDItem
9925                 Item uint32
9926
9927                 //mt:if %s.Field == HUDDir
9928                 Dir uint32
9929
9930                 //mt:if %s.Field == HUDAlign
9931                 Align [2]float32
9932
9933                 //mt:if %s.Field == HUDOffset
9934                 Offset [2]float32
9935
9936                 //mt:if %s.Field == HUDWorldPos
9937                 WorldPos Pos
9938
9939                 //mt:if %s.Field == HUDSize
9940                 Size [2]int32
9941
9942                 //mt:if %s.Field == HUDZIndex
9943                 ZIndex int32
9944
9945                 //mt:if %s.Field == HUDText2
9946                 Text2 string
9947
9948                 //mt:if %s.Field == HUDStyle
9949                 Style HUDStyleFlags
9950         }))(obj)).Field == HUDText {
9951                 var local181 []uint8
9952                 var local182 uint16
9953                 {
9954                         p := &local182
9955                         *p = read16(r)
9956                 }
9957                 (local181) = make([]uint8, local182)
9958                 {
9959                         _, err := io.ReadFull(r, (local181)[:])
9960                         chk(err)
9961                 }
9962                 ((*(*(struct {
9963                         ID HUDID
9964
9965                         Field HUDField
9966
9967                         //mt:if %s.Field == HUDPos
9968                         Pos [2]float32
9969
9970                         //mt:if %s.Field == HUDName
9971                         Name string
9972
9973                         //mt:if %s.Field == HUDScale
9974                         Scale [2]float32
9975
9976                         //mt:if %s.Field == HUDText
9977                         Text string
9978
9979                         //mt:if %s.Field == HUDNumber
9980                         Number uint32
9981
9982                         //mt:if %s.Field == HUDItem
9983                         Item uint32
9984
9985                         //mt:if %s.Field == HUDDir
9986                         Dir uint32
9987
9988                         //mt:if %s.Field == HUDAlign
9989                         Align [2]float32
9990
9991                         //mt:if %s.Field == HUDOffset
9992                         Offset [2]float32
9993
9994                         //mt:if %s.Field == HUDWorldPos
9995                         WorldPos Pos
9996
9997                         //mt:if %s.Field == HUDSize
9998                         Size [2]int32
9999
10000                         //mt:if %s.Field == HUDZIndex
10001                         ZIndex int32
10002
10003                         //mt:if %s.Field == HUDText2
10004                         Text2 string
10005
10006                         //mt:if %s.Field == HUDStyle
10007                         Style HUDStyleFlags
10008                 }))(obj)).Text) = string(local181)
10009         }
10010         if (*(*(struct {
10011                 ID HUDID
10012
10013                 Field HUDField
10014
10015                 //mt:if %s.Field == HUDPos
10016                 Pos [2]float32
10017
10018                 //mt:if %s.Field == HUDName
10019                 Name string
10020
10021                 //mt:if %s.Field == HUDScale
10022                 Scale [2]float32
10023
10024                 //mt:if %s.Field == HUDText
10025                 Text string
10026
10027                 //mt:if %s.Field == HUDNumber
10028                 Number uint32
10029
10030                 //mt:if %s.Field == HUDItem
10031                 Item uint32
10032
10033                 //mt:if %s.Field == HUDDir
10034                 Dir uint32
10035
10036                 //mt:if %s.Field == HUDAlign
10037                 Align [2]float32
10038
10039                 //mt:if %s.Field == HUDOffset
10040                 Offset [2]float32
10041
10042                 //mt:if %s.Field == HUDWorldPos
10043                 WorldPos Pos
10044
10045                 //mt:if %s.Field == HUDSize
10046                 Size [2]int32
10047
10048                 //mt:if %s.Field == HUDZIndex
10049                 ZIndex int32
10050
10051                 //mt:if %s.Field == HUDText2
10052                 Text2 string
10053
10054                 //mt:if %s.Field == HUDStyle
10055                 Style HUDStyleFlags
10056         }))(obj)).Field == HUDNumber {
10057                 {
10058                         p := &(*(*(struct {
10059                                 ID HUDID
10060
10061                                 Field HUDField
10062
10063                                 //mt:if %s.Field == HUDPos
10064                                 Pos [2]float32
10065
10066                                 //mt:if %s.Field == HUDName
10067                                 Name string
10068
10069                                 //mt:if %s.Field == HUDScale
10070                                 Scale [2]float32
10071
10072                                 //mt:if %s.Field == HUDText
10073                                 Text string
10074
10075                                 //mt:if %s.Field == HUDNumber
10076                                 Number uint32
10077
10078                                 //mt:if %s.Field == HUDItem
10079                                 Item uint32
10080
10081                                 //mt:if %s.Field == HUDDir
10082                                 Dir uint32
10083
10084                                 //mt:if %s.Field == HUDAlign
10085                                 Align [2]float32
10086
10087                                 //mt:if %s.Field == HUDOffset
10088                                 Offset [2]float32
10089
10090                                 //mt:if %s.Field == HUDWorldPos
10091                                 WorldPos Pos
10092
10093                                 //mt:if %s.Field == HUDSize
10094                                 Size [2]int32
10095
10096                                 //mt:if %s.Field == HUDZIndex
10097                                 ZIndex int32
10098
10099                                 //mt:if %s.Field == HUDText2
10100                                 Text2 string
10101
10102                                 //mt:if %s.Field == HUDStyle
10103                                 Style HUDStyleFlags
10104                         }))(obj)).Number
10105                         *p = read32(r)
10106                 }
10107         }
10108         if (*(*(struct {
10109                 ID HUDID
10110
10111                 Field HUDField
10112
10113                 //mt:if %s.Field == HUDPos
10114                 Pos [2]float32
10115
10116                 //mt:if %s.Field == HUDName
10117                 Name string
10118
10119                 //mt:if %s.Field == HUDScale
10120                 Scale [2]float32
10121
10122                 //mt:if %s.Field == HUDText
10123                 Text string
10124
10125                 //mt:if %s.Field == HUDNumber
10126                 Number uint32
10127
10128                 //mt:if %s.Field == HUDItem
10129                 Item uint32
10130
10131                 //mt:if %s.Field == HUDDir
10132                 Dir uint32
10133
10134                 //mt:if %s.Field == HUDAlign
10135                 Align [2]float32
10136
10137                 //mt:if %s.Field == HUDOffset
10138                 Offset [2]float32
10139
10140                 //mt:if %s.Field == HUDWorldPos
10141                 WorldPos Pos
10142
10143                 //mt:if %s.Field == HUDSize
10144                 Size [2]int32
10145
10146                 //mt:if %s.Field == HUDZIndex
10147                 ZIndex int32
10148
10149                 //mt:if %s.Field == HUDText2
10150                 Text2 string
10151
10152                 //mt:if %s.Field == HUDStyle
10153                 Style HUDStyleFlags
10154         }))(obj)).Field == HUDItem {
10155                 {
10156                         p := &(*(*(struct {
10157                                 ID HUDID
10158
10159                                 Field HUDField
10160
10161                                 //mt:if %s.Field == HUDPos
10162                                 Pos [2]float32
10163
10164                                 //mt:if %s.Field == HUDName
10165                                 Name string
10166
10167                                 //mt:if %s.Field == HUDScale
10168                                 Scale [2]float32
10169
10170                                 //mt:if %s.Field == HUDText
10171                                 Text string
10172
10173                                 //mt:if %s.Field == HUDNumber
10174                                 Number uint32
10175
10176                                 //mt:if %s.Field == HUDItem
10177                                 Item uint32
10178
10179                                 //mt:if %s.Field == HUDDir
10180                                 Dir uint32
10181
10182                                 //mt:if %s.Field == HUDAlign
10183                                 Align [2]float32
10184
10185                                 //mt:if %s.Field == HUDOffset
10186                                 Offset [2]float32
10187
10188                                 //mt:if %s.Field == HUDWorldPos
10189                                 WorldPos Pos
10190
10191                                 //mt:if %s.Field == HUDSize
10192                                 Size [2]int32
10193
10194                                 //mt:if %s.Field == HUDZIndex
10195                                 ZIndex int32
10196
10197                                 //mt:if %s.Field == HUDText2
10198                                 Text2 string
10199
10200                                 //mt:if %s.Field == HUDStyle
10201                                 Style HUDStyleFlags
10202                         }))(obj)).Item
10203                         *p = read32(r)
10204                 }
10205         }
10206         if (*(*(struct {
10207                 ID HUDID
10208
10209                 Field HUDField
10210
10211                 //mt:if %s.Field == HUDPos
10212                 Pos [2]float32
10213
10214                 //mt:if %s.Field == HUDName
10215                 Name string
10216
10217                 //mt:if %s.Field == HUDScale
10218                 Scale [2]float32
10219
10220                 //mt:if %s.Field == HUDText
10221                 Text string
10222
10223                 //mt:if %s.Field == HUDNumber
10224                 Number uint32
10225
10226                 //mt:if %s.Field == HUDItem
10227                 Item uint32
10228
10229                 //mt:if %s.Field == HUDDir
10230                 Dir uint32
10231
10232                 //mt:if %s.Field == HUDAlign
10233                 Align [2]float32
10234
10235                 //mt:if %s.Field == HUDOffset
10236                 Offset [2]float32
10237
10238                 //mt:if %s.Field == HUDWorldPos
10239                 WorldPos Pos
10240
10241                 //mt:if %s.Field == HUDSize
10242                 Size [2]int32
10243
10244                 //mt:if %s.Field == HUDZIndex
10245                 ZIndex int32
10246
10247                 //mt:if %s.Field == HUDText2
10248                 Text2 string
10249
10250                 //mt:if %s.Field == HUDStyle
10251                 Style HUDStyleFlags
10252         }))(obj)).Field == HUDDir {
10253                 {
10254                         p := &(*(*(struct {
10255                                 ID HUDID
10256
10257                                 Field HUDField
10258
10259                                 //mt:if %s.Field == HUDPos
10260                                 Pos [2]float32
10261
10262                                 //mt:if %s.Field == HUDName
10263                                 Name string
10264
10265                                 //mt:if %s.Field == HUDScale
10266                                 Scale [2]float32
10267
10268                                 //mt:if %s.Field == HUDText
10269                                 Text string
10270
10271                                 //mt:if %s.Field == HUDNumber
10272                                 Number uint32
10273
10274                                 //mt:if %s.Field == HUDItem
10275                                 Item uint32
10276
10277                                 //mt:if %s.Field == HUDDir
10278                                 Dir uint32
10279
10280                                 //mt:if %s.Field == HUDAlign
10281                                 Align [2]float32
10282
10283                                 //mt:if %s.Field == HUDOffset
10284                                 Offset [2]float32
10285
10286                                 //mt:if %s.Field == HUDWorldPos
10287                                 WorldPos Pos
10288
10289                                 //mt:if %s.Field == HUDSize
10290                                 Size [2]int32
10291
10292                                 //mt:if %s.Field == HUDZIndex
10293                                 ZIndex int32
10294
10295                                 //mt:if %s.Field == HUDText2
10296                                 Text2 string
10297
10298                                 //mt:if %s.Field == HUDStyle
10299                                 Style HUDStyleFlags
10300                         }))(obj)).Dir
10301                         *p = read32(r)
10302                 }
10303         }
10304         if (*(*(struct {
10305                 ID HUDID
10306
10307                 Field HUDField
10308
10309                 //mt:if %s.Field == HUDPos
10310                 Pos [2]float32
10311
10312                 //mt:if %s.Field == HUDName
10313                 Name string
10314
10315                 //mt:if %s.Field == HUDScale
10316                 Scale [2]float32
10317
10318                 //mt:if %s.Field == HUDText
10319                 Text string
10320
10321                 //mt:if %s.Field == HUDNumber
10322                 Number uint32
10323
10324                 //mt:if %s.Field == HUDItem
10325                 Item uint32
10326
10327                 //mt:if %s.Field == HUDDir
10328                 Dir uint32
10329
10330                 //mt:if %s.Field == HUDAlign
10331                 Align [2]float32
10332
10333                 //mt:if %s.Field == HUDOffset
10334                 Offset [2]float32
10335
10336                 //mt:if %s.Field == HUDWorldPos
10337                 WorldPos Pos
10338
10339                 //mt:if %s.Field == HUDSize
10340                 Size [2]int32
10341
10342                 //mt:if %s.Field == HUDZIndex
10343                 ZIndex int32
10344
10345                 //mt:if %s.Field == HUDText2
10346                 Text2 string
10347
10348                 //mt:if %s.Field == HUDStyle
10349                 Style HUDStyleFlags
10350         }))(obj)).Field == HUDAlign {
10351                 for local183 := range (*(*(struct {
10352                         ID HUDID
10353
10354                         Field HUDField
10355
10356                         //mt:if %s.Field == HUDPos
10357                         Pos [2]float32
10358
10359                         //mt:if %s.Field == HUDName
10360                         Name string
10361
10362                         //mt:if %s.Field == HUDScale
10363                         Scale [2]float32
10364
10365                         //mt:if %s.Field == HUDText
10366                         Text string
10367
10368                         //mt:if %s.Field == HUDNumber
10369                         Number uint32
10370
10371                         //mt:if %s.Field == HUDItem
10372                         Item uint32
10373
10374                         //mt:if %s.Field == HUDDir
10375                         Dir uint32
10376
10377                         //mt:if %s.Field == HUDAlign
10378                         Align [2]float32
10379
10380                         //mt:if %s.Field == HUDOffset
10381                         Offset [2]float32
10382
10383                         //mt:if %s.Field == HUDWorldPos
10384                         WorldPos Pos
10385
10386                         //mt:if %s.Field == HUDSize
10387                         Size [2]int32
10388
10389                         //mt:if %s.Field == HUDZIndex
10390                         ZIndex int32
10391
10392                         //mt:if %s.Field == HUDText2
10393                         Text2 string
10394
10395                         //mt:if %s.Field == HUDStyle
10396                         Style HUDStyleFlags
10397                 }))(obj)).Align {
10398                         {
10399                                 p := &((*(*(struct {
10400                                         ID HUDID
10401
10402                                         Field HUDField
10403
10404                                         //mt:if %s.Field == HUDPos
10405                                         Pos [2]float32
10406
10407                                         //mt:if %s.Field == HUDName
10408                                         Name string
10409
10410                                         //mt:if %s.Field == HUDScale
10411                                         Scale [2]float32
10412
10413                                         //mt:if %s.Field == HUDText
10414                                         Text string
10415
10416                                         //mt:if %s.Field == HUDNumber
10417                                         Number uint32
10418
10419                                         //mt:if %s.Field == HUDItem
10420                                         Item uint32
10421
10422                                         //mt:if %s.Field == HUDDir
10423                                         Dir uint32
10424
10425                                         //mt:if %s.Field == HUDAlign
10426                                         Align [2]float32
10427
10428                                         //mt:if %s.Field == HUDOffset
10429                                         Offset [2]float32
10430
10431                                         //mt:if %s.Field == HUDWorldPos
10432                                         WorldPos Pos
10433
10434                                         //mt:if %s.Field == HUDSize
10435                                         Size [2]int32
10436
10437                                         //mt:if %s.Field == HUDZIndex
10438                                         ZIndex int32
10439
10440                                         //mt:if %s.Field == HUDText2
10441                                         Text2 string
10442
10443                                         //mt:if %s.Field == HUDStyle
10444                                         Style HUDStyleFlags
10445                                 }))(obj)).Align)[local183]
10446                                 *p = math.Float32frombits(read32(r))
10447                         }
10448                 }
10449         }
10450         if (*(*(struct {
10451                 ID HUDID
10452
10453                 Field HUDField
10454
10455                 //mt:if %s.Field == HUDPos
10456                 Pos [2]float32
10457
10458                 //mt:if %s.Field == HUDName
10459                 Name string
10460
10461                 //mt:if %s.Field == HUDScale
10462                 Scale [2]float32
10463
10464                 //mt:if %s.Field == HUDText
10465                 Text string
10466
10467                 //mt:if %s.Field == HUDNumber
10468                 Number uint32
10469
10470                 //mt:if %s.Field == HUDItem
10471                 Item uint32
10472
10473                 //mt:if %s.Field == HUDDir
10474                 Dir uint32
10475
10476                 //mt:if %s.Field == HUDAlign
10477                 Align [2]float32
10478
10479                 //mt:if %s.Field == HUDOffset
10480                 Offset [2]float32
10481
10482                 //mt:if %s.Field == HUDWorldPos
10483                 WorldPos Pos
10484
10485                 //mt:if %s.Field == HUDSize
10486                 Size [2]int32
10487
10488                 //mt:if %s.Field == HUDZIndex
10489                 ZIndex int32
10490
10491                 //mt:if %s.Field == HUDText2
10492                 Text2 string
10493
10494                 //mt:if %s.Field == HUDStyle
10495                 Style HUDStyleFlags
10496         }))(obj)).Field == HUDOffset {
10497                 for local184 := range (*(*(struct {
10498                         ID HUDID
10499
10500                         Field HUDField
10501
10502                         //mt:if %s.Field == HUDPos
10503                         Pos [2]float32
10504
10505                         //mt:if %s.Field == HUDName
10506                         Name string
10507
10508                         //mt:if %s.Field == HUDScale
10509                         Scale [2]float32
10510
10511                         //mt:if %s.Field == HUDText
10512                         Text string
10513
10514                         //mt:if %s.Field == HUDNumber
10515                         Number uint32
10516
10517                         //mt:if %s.Field == HUDItem
10518                         Item uint32
10519
10520                         //mt:if %s.Field == HUDDir
10521                         Dir uint32
10522
10523                         //mt:if %s.Field == HUDAlign
10524                         Align [2]float32
10525
10526                         //mt:if %s.Field == HUDOffset
10527                         Offset [2]float32
10528
10529                         //mt:if %s.Field == HUDWorldPos
10530                         WorldPos Pos
10531
10532                         //mt:if %s.Field == HUDSize
10533                         Size [2]int32
10534
10535                         //mt:if %s.Field == HUDZIndex
10536                         ZIndex int32
10537
10538                         //mt:if %s.Field == HUDText2
10539                         Text2 string
10540
10541                         //mt:if %s.Field == HUDStyle
10542                         Style HUDStyleFlags
10543                 }))(obj)).Offset {
10544                         {
10545                                 p := &((*(*(struct {
10546                                         ID HUDID
10547
10548                                         Field HUDField
10549
10550                                         //mt:if %s.Field == HUDPos
10551                                         Pos [2]float32
10552
10553                                         //mt:if %s.Field == HUDName
10554                                         Name string
10555
10556                                         //mt:if %s.Field == HUDScale
10557                                         Scale [2]float32
10558
10559                                         //mt:if %s.Field == HUDText
10560                                         Text string
10561
10562                                         //mt:if %s.Field == HUDNumber
10563                                         Number uint32
10564
10565                                         //mt:if %s.Field == HUDItem
10566                                         Item uint32
10567
10568                                         //mt:if %s.Field == HUDDir
10569                                         Dir uint32
10570
10571                                         //mt:if %s.Field == HUDAlign
10572                                         Align [2]float32
10573
10574                                         //mt:if %s.Field == HUDOffset
10575                                         Offset [2]float32
10576
10577                                         //mt:if %s.Field == HUDWorldPos
10578                                         WorldPos Pos
10579
10580                                         //mt:if %s.Field == HUDSize
10581                                         Size [2]int32
10582
10583                                         //mt:if %s.Field == HUDZIndex
10584                                         ZIndex int32
10585
10586                                         //mt:if %s.Field == HUDText2
10587                                         Text2 string
10588
10589                                         //mt:if %s.Field == HUDStyle
10590                                         Style HUDStyleFlags
10591                                 }))(obj)).Offset)[local184]
10592                                 *p = math.Float32frombits(read32(r))
10593                         }
10594                 }
10595         }
10596         if (*(*(struct {
10597                 ID HUDID
10598
10599                 Field HUDField
10600
10601                 //mt:if %s.Field == HUDPos
10602                 Pos [2]float32
10603
10604                 //mt:if %s.Field == HUDName
10605                 Name string
10606
10607                 //mt:if %s.Field == HUDScale
10608                 Scale [2]float32
10609
10610                 //mt:if %s.Field == HUDText
10611                 Text string
10612
10613                 //mt:if %s.Field == HUDNumber
10614                 Number uint32
10615
10616                 //mt:if %s.Field == HUDItem
10617                 Item uint32
10618
10619                 //mt:if %s.Field == HUDDir
10620                 Dir uint32
10621
10622                 //mt:if %s.Field == HUDAlign
10623                 Align [2]float32
10624
10625                 //mt:if %s.Field == HUDOffset
10626                 Offset [2]float32
10627
10628                 //mt:if %s.Field == HUDWorldPos
10629                 WorldPos Pos
10630
10631                 //mt:if %s.Field == HUDSize
10632                 Size [2]int32
10633
10634                 //mt:if %s.Field == HUDZIndex
10635                 ZIndex int32
10636
10637                 //mt:if %s.Field == HUDText2
10638                 Text2 string
10639
10640                 //mt:if %s.Field == HUDStyle
10641                 Style HUDStyleFlags
10642         }))(obj)).Field == HUDWorldPos {
10643                 if err := pcall(func() {
10644                         ((*(*(struct {
10645                                 ID HUDID
10646
10647                                 Field HUDField
10648
10649                                 //mt:if %s.Field == HUDPos
10650                                 Pos [2]float32
10651
10652                                 //mt:if %s.Field == HUDName
10653                                 Name string
10654
10655                                 //mt:if %s.Field == HUDScale
10656                                 Scale [2]float32
10657
10658                                 //mt:if %s.Field == HUDText
10659                                 Text string
10660
10661                                 //mt:if %s.Field == HUDNumber
10662                                 Number uint32
10663
10664                                 //mt:if %s.Field == HUDItem
10665                                 Item uint32
10666
10667                                 //mt:if %s.Field == HUDDir
10668                                 Dir uint32
10669
10670                                 //mt:if %s.Field == HUDAlign
10671                                 Align [2]float32
10672
10673                                 //mt:if %s.Field == HUDOffset
10674                                 Offset [2]float32
10675
10676                                 //mt:if %s.Field == HUDWorldPos
10677                                 WorldPos Pos
10678
10679                                 //mt:if %s.Field == HUDSize
10680                                 Size [2]int32
10681
10682                                 //mt:if %s.Field == HUDZIndex
10683                                 ZIndex int32
10684
10685                                 //mt:if %s.Field == HUDText2
10686                                 Text2 string
10687
10688                                 //mt:if %s.Field == HUDStyle
10689                                 Style HUDStyleFlags
10690                         }))(obj)).WorldPos).deserialize(r)
10691                 }); err != nil {
10692                         if err == io.EOF {
10693                                 chk(io.EOF)
10694                         }
10695                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
10696                 }
10697         }
10698         if (*(*(struct {
10699                 ID HUDID
10700
10701                 Field HUDField
10702
10703                 //mt:if %s.Field == HUDPos
10704                 Pos [2]float32
10705
10706                 //mt:if %s.Field == HUDName
10707                 Name string
10708
10709                 //mt:if %s.Field == HUDScale
10710                 Scale [2]float32
10711
10712                 //mt:if %s.Field == HUDText
10713                 Text string
10714
10715                 //mt:if %s.Field == HUDNumber
10716                 Number uint32
10717
10718                 //mt:if %s.Field == HUDItem
10719                 Item uint32
10720
10721                 //mt:if %s.Field == HUDDir
10722                 Dir uint32
10723
10724                 //mt:if %s.Field == HUDAlign
10725                 Align [2]float32
10726
10727                 //mt:if %s.Field == HUDOffset
10728                 Offset [2]float32
10729
10730                 //mt:if %s.Field == HUDWorldPos
10731                 WorldPos Pos
10732
10733                 //mt:if %s.Field == HUDSize
10734                 Size [2]int32
10735
10736                 //mt:if %s.Field == HUDZIndex
10737                 ZIndex int32
10738
10739                 //mt:if %s.Field == HUDText2
10740                 Text2 string
10741
10742                 //mt:if %s.Field == HUDStyle
10743                 Style HUDStyleFlags
10744         }))(obj)).Field == HUDSize {
10745                 for local185 := range (*(*(struct {
10746                         ID HUDID
10747
10748                         Field HUDField
10749
10750                         //mt:if %s.Field == HUDPos
10751                         Pos [2]float32
10752
10753                         //mt:if %s.Field == HUDName
10754                         Name string
10755
10756                         //mt:if %s.Field == HUDScale
10757                         Scale [2]float32
10758
10759                         //mt:if %s.Field == HUDText
10760                         Text string
10761
10762                         //mt:if %s.Field == HUDNumber
10763                         Number uint32
10764
10765                         //mt:if %s.Field == HUDItem
10766                         Item uint32
10767
10768                         //mt:if %s.Field == HUDDir
10769                         Dir uint32
10770
10771                         //mt:if %s.Field == HUDAlign
10772                         Align [2]float32
10773
10774                         //mt:if %s.Field == HUDOffset
10775                         Offset [2]float32
10776
10777                         //mt:if %s.Field == HUDWorldPos
10778                         WorldPos Pos
10779
10780                         //mt:if %s.Field == HUDSize
10781                         Size [2]int32
10782
10783                         //mt:if %s.Field == HUDZIndex
10784                         ZIndex int32
10785
10786                         //mt:if %s.Field == HUDText2
10787                         Text2 string
10788
10789                         //mt:if %s.Field == HUDStyle
10790                         Style HUDStyleFlags
10791                 }))(obj)).Size {
10792                         {
10793                                 p := &((*(*(struct {
10794                                         ID HUDID
10795
10796                                         Field HUDField
10797
10798                                         //mt:if %s.Field == HUDPos
10799                                         Pos [2]float32
10800
10801                                         //mt:if %s.Field == HUDName
10802                                         Name string
10803
10804                                         //mt:if %s.Field == HUDScale
10805                                         Scale [2]float32
10806
10807                                         //mt:if %s.Field == HUDText
10808                                         Text string
10809
10810                                         //mt:if %s.Field == HUDNumber
10811                                         Number uint32
10812
10813                                         //mt:if %s.Field == HUDItem
10814                                         Item uint32
10815
10816                                         //mt:if %s.Field == HUDDir
10817                                         Dir uint32
10818
10819                                         //mt:if %s.Field == HUDAlign
10820                                         Align [2]float32
10821
10822                                         //mt:if %s.Field == HUDOffset
10823                                         Offset [2]float32
10824
10825                                         //mt:if %s.Field == HUDWorldPos
10826                                         WorldPos Pos
10827
10828                                         //mt:if %s.Field == HUDSize
10829                                         Size [2]int32
10830
10831                                         //mt:if %s.Field == HUDZIndex
10832                                         ZIndex int32
10833
10834                                         //mt:if %s.Field == HUDText2
10835                                         Text2 string
10836
10837                                         //mt:if %s.Field == HUDStyle
10838                                         Style HUDStyleFlags
10839                                 }))(obj)).Size)[local185]
10840                                 *p = int32(read32(r))
10841                         }
10842                 }
10843         }
10844         if (*(*(struct {
10845                 ID HUDID
10846
10847                 Field HUDField
10848
10849                 //mt:if %s.Field == HUDPos
10850                 Pos [2]float32
10851
10852                 //mt:if %s.Field == HUDName
10853                 Name string
10854
10855                 //mt:if %s.Field == HUDScale
10856                 Scale [2]float32
10857
10858                 //mt:if %s.Field == HUDText
10859                 Text string
10860
10861                 //mt:if %s.Field == HUDNumber
10862                 Number uint32
10863
10864                 //mt:if %s.Field == HUDItem
10865                 Item uint32
10866
10867                 //mt:if %s.Field == HUDDir
10868                 Dir uint32
10869
10870                 //mt:if %s.Field == HUDAlign
10871                 Align [2]float32
10872
10873                 //mt:if %s.Field == HUDOffset
10874                 Offset [2]float32
10875
10876                 //mt:if %s.Field == HUDWorldPos
10877                 WorldPos Pos
10878
10879                 //mt:if %s.Field == HUDSize
10880                 Size [2]int32
10881
10882                 //mt:if %s.Field == HUDZIndex
10883                 ZIndex int32
10884
10885                 //mt:if %s.Field == HUDText2
10886                 Text2 string
10887
10888                 //mt:if %s.Field == HUDStyle
10889                 Style HUDStyleFlags
10890         }))(obj)).Field == HUDZIndex {
10891                 {
10892                         p := &(*(*(struct {
10893                                 ID HUDID
10894
10895                                 Field HUDField
10896
10897                                 //mt:if %s.Field == HUDPos
10898                                 Pos [2]float32
10899
10900                                 //mt:if %s.Field == HUDName
10901                                 Name string
10902
10903                                 //mt:if %s.Field == HUDScale
10904                                 Scale [2]float32
10905
10906                                 //mt:if %s.Field == HUDText
10907                                 Text string
10908
10909                                 //mt:if %s.Field == HUDNumber
10910                                 Number uint32
10911
10912                                 //mt:if %s.Field == HUDItem
10913                                 Item uint32
10914
10915                                 //mt:if %s.Field == HUDDir
10916                                 Dir uint32
10917
10918                                 //mt:if %s.Field == HUDAlign
10919                                 Align [2]float32
10920
10921                                 //mt:if %s.Field == HUDOffset
10922                                 Offset [2]float32
10923
10924                                 //mt:if %s.Field == HUDWorldPos
10925                                 WorldPos Pos
10926
10927                                 //mt:if %s.Field == HUDSize
10928                                 Size [2]int32
10929
10930                                 //mt:if %s.Field == HUDZIndex
10931                                 ZIndex int32
10932
10933                                 //mt:if %s.Field == HUDText2
10934                                 Text2 string
10935
10936                                 //mt:if %s.Field == HUDStyle
10937                                 Style HUDStyleFlags
10938                         }))(obj)).ZIndex
10939                         *p = int32(read32(r))
10940                 }
10941         }
10942         if (*(*(struct {
10943                 ID HUDID
10944
10945                 Field HUDField
10946
10947                 //mt:if %s.Field == HUDPos
10948                 Pos [2]float32
10949
10950                 //mt:if %s.Field == HUDName
10951                 Name string
10952
10953                 //mt:if %s.Field == HUDScale
10954                 Scale [2]float32
10955
10956                 //mt:if %s.Field == HUDText
10957                 Text string
10958
10959                 //mt:if %s.Field == HUDNumber
10960                 Number uint32
10961
10962                 //mt:if %s.Field == HUDItem
10963                 Item uint32
10964
10965                 //mt:if %s.Field == HUDDir
10966                 Dir uint32
10967
10968                 //mt:if %s.Field == HUDAlign
10969                 Align [2]float32
10970
10971                 //mt:if %s.Field == HUDOffset
10972                 Offset [2]float32
10973
10974                 //mt:if %s.Field == HUDWorldPos
10975                 WorldPos Pos
10976
10977                 //mt:if %s.Field == HUDSize
10978                 Size [2]int32
10979
10980                 //mt:if %s.Field == HUDZIndex
10981                 ZIndex int32
10982
10983                 //mt:if %s.Field == HUDText2
10984                 Text2 string
10985
10986                 //mt:if %s.Field == HUDStyle
10987                 Style HUDStyleFlags
10988         }))(obj)).Field == HUDText2 {
10989                 var local186 []uint8
10990                 var local187 uint16
10991                 {
10992                         p := &local187
10993                         *p = read16(r)
10994                 }
10995                 (local186) = make([]uint8, local187)
10996                 {
10997                         _, err := io.ReadFull(r, (local186)[:])
10998                         chk(err)
10999                 }
11000                 ((*(*(struct {
11001                         ID HUDID
11002
11003                         Field HUDField
11004
11005                         //mt:if %s.Field == HUDPos
11006                         Pos [2]float32
11007
11008                         //mt:if %s.Field == HUDName
11009                         Name string
11010
11011                         //mt:if %s.Field == HUDScale
11012                         Scale [2]float32
11013
11014                         //mt:if %s.Field == HUDText
11015                         Text string
11016
11017                         //mt:if %s.Field == HUDNumber
11018                         Number uint32
11019
11020                         //mt:if %s.Field == HUDItem
11021                         Item uint32
11022
11023                         //mt:if %s.Field == HUDDir
11024                         Dir uint32
11025
11026                         //mt:if %s.Field == HUDAlign
11027                         Align [2]float32
11028
11029                         //mt:if %s.Field == HUDOffset
11030                         Offset [2]float32
11031
11032                         //mt:if %s.Field == HUDWorldPos
11033                         WorldPos Pos
11034
11035                         //mt:if %s.Field == HUDSize
11036                         Size [2]int32
11037
11038                         //mt:if %s.Field == HUDZIndex
11039                         ZIndex int32
11040
11041                         //mt:if %s.Field == HUDText2
11042                         Text2 string
11043
11044                         //mt:if %s.Field == HUDStyle
11045                         Style HUDStyleFlags
11046                 }))(obj)).Text2) = string(local186)
11047         }
11048         if (*(*(struct {
11049                 ID HUDID
11050
11051                 Field HUDField
11052
11053                 //mt:if %s.Field == HUDPos
11054                 Pos [2]float32
11055
11056                 //mt:if %s.Field == HUDName
11057                 Name string
11058
11059                 //mt:if %s.Field == HUDScale
11060                 Scale [2]float32
11061
11062                 //mt:if %s.Field == HUDText
11063                 Text string
11064
11065                 //mt:if %s.Field == HUDNumber
11066                 Number uint32
11067
11068                 //mt:if %s.Field == HUDItem
11069                 Item uint32
11070
11071                 //mt:if %s.Field == HUDDir
11072                 Dir uint32
11073
11074                 //mt:if %s.Field == HUDAlign
11075                 Align [2]float32
11076
11077                 //mt:if %s.Field == HUDOffset
11078                 Offset [2]float32
11079
11080                 //mt:if %s.Field == HUDWorldPos
11081                 WorldPos Pos
11082
11083                 //mt:if %s.Field == HUDSize
11084                 Size [2]int32
11085
11086                 //mt:if %s.Field == HUDZIndex
11087                 ZIndex int32
11088
11089                 //mt:if %s.Field == HUDText2
11090                 Text2 string
11091
11092                 //mt:if %s.Field == HUDStyle
11093                 Style HUDStyleFlags
11094         }))(obj)).Field == HUDStyle {
11095                 if err := pcall(func() {
11096                         ((*(*(struct {
11097                                 ID HUDID
11098
11099                                 Field HUDField
11100
11101                                 //mt:if %s.Field == HUDPos
11102                                 Pos [2]float32
11103
11104                                 //mt:if %s.Field == HUDName
11105                                 Name string
11106
11107                                 //mt:if %s.Field == HUDScale
11108                                 Scale [2]float32
11109
11110                                 //mt:if %s.Field == HUDText
11111                                 Text string
11112
11113                                 //mt:if %s.Field == HUDNumber
11114                                 Number uint32
11115
11116                                 //mt:if %s.Field == HUDItem
11117                                 Item uint32
11118
11119                                 //mt:if %s.Field == HUDDir
11120                                 Dir uint32
11121
11122                                 //mt:if %s.Field == HUDAlign
11123                                 Align [2]float32
11124
11125                                 //mt:if %s.Field == HUDOffset
11126                                 Offset [2]float32
11127
11128                                 //mt:if %s.Field == HUDWorldPos
11129                                 WorldPos Pos
11130
11131                                 //mt:if %s.Field == HUDSize
11132                                 Size [2]int32
11133
11134                                 //mt:if %s.Field == HUDZIndex
11135                                 ZIndex int32
11136
11137                                 //mt:if %s.Field == HUDText2
11138                                 Text2 string
11139
11140                                 //mt:if %s.Field == HUDStyle
11141                                 Style HUDStyleFlags
11142                         }))(obj)).Style).deserialize(r)
11143                 }); err != nil {
11144                         if err == io.EOF {
11145                                 chk(io.EOF)
11146                         }
11147                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
11148                 }
11149         }
11150 }
11151
11152 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
11153         if err := pcall(func() {
11154                 ((*(*(struct {
11155                         // &^= Mask
11156                         // |= Flags
11157                         Flags, Mask HUDFlags
11158                 }))(obj)).Flags).serialize(w)
11159         }); err != nil {
11160                 if err == io.EOF {
11161                         chk(io.EOF)
11162                 }
11163                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11164         }
11165         if err := pcall(func() {
11166                 ((*(*(struct {
11167                         // &^= Mask
11168                         // |= Flags
11169                         Flags, Mask HUDFlags
11170                 }))(obj)).Mask).serialize(w)
11171         }); err != nil {
11172                 if err == io.EOF {
11173                         chk(io.EOF)
11174                 }
11175                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11176         }
11177 }
11178
11179 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
11180         if err := pcall(func() {
11181                 ((*(*(struct {
11182                         // &^= Mask
11183                         // |= Flags
11184                         Flags, Mask HUDFlags
11185                 }))(obj)).Flags).deserialize(r)
11186         }); err != nil {
11187                 if err == io.EOF {
11188                         chk(io.EOF)
11189                 }
11190                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11191         }
11192         if err := pcall(func() {
11193                 ((*(*(struct {
11194                         // &^= Mask
11195                         // |= Flags
11196                         Flags, Mask HUDFlags
11197                 }))(obj)).Mask).deserialize(r)
11198         }); err != nil {
11199                 if err == io.EOF {
11200                         chk(io.EOF)
11201                 }
11202                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11203         }
11204 }
11205
11206 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
11207         if err := pcall(func() {
11208                 ((*(*(struct {
11209                         Param HotbarParam
11210
11211                         //mt:if %s.Param == HotbarSize
11212                         //mt:const uint16(4) // Size of Size field.
11213                         Size int32
11214
11215                         //mt:if %s.Param != HotbarSize
11216                         Img Texture
11217                 }))(obj)).Param).serialize(w)
11218         }); err != nil {
11219                 if err == io.EOF {
11220                         chk(io.EOF)
11221                 }
11222                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11223         }
11224         if (*(*(struct {
11225                 Param HotbarParam
11226
11227                 //mt:if %s.Param == HotbarSize
11228                 //mt:const uint16(4) // Size of Size field.
11229                 Size int32
11230
11231                 //mt:if %s.Param != HotbarSize
11232                 Img Texture
11233         }))(obj)).Param == HotbarSize {
11234                 {
11235                         local188 := uint16(4) // Size of Size field.
11236                         {
11237                                 x := local188
11238                                 write16(w, uint16(x))
11239                         }
11240                 }
11241                 {
11242                         x := (*(*(struct {
11243                                 Param HotbarParam
11244
11245                                 //mt:if %s.Param == HotbarSize
11246                                 //mt:const uint16(4) // Size of Size field.
11247                                 Size int32
11248
11249                                 //mt:if %s.Param != HotbarSize
11250                                 Img Texture
11251                         }))(obj)).Size
11252                         write32(w, uint32(x))
11253                 }
11254         }
11255         if (*(*(struct {
11256                 Param HotbarParam
11257
11258                 //mt:if %s.Param == HotbarSize
11259                 //mt:const uint16(4) // Size of Size field.
11260                 Size int32
11261
11262                 //mt:if %s.Param != HotbarSize
11263                 Img Texture
11264         }))(obj)).Param != HotbarSize {
11265                 if err := pcall(func() {
11266                         ((*(*(struct {
11267                                 Param HotbarParam
11268
11269                                 //mt:if %s.Param == HotbarSize
11270                                 //mt:const uint16(4) // Size of Size field.
11271                                 Size int32
11272
11273                                 //mt:if %s.Param != HotbarSize
11274                                 Img Texture
11275                         }))(obj)).Img).serialize(w)
11276                 }); err != nil {
11277                         if err == io.EOF {
11278                                 chk(io.EOF)
11279                         }
11280                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11281                 }
11282         }
11283 }
11284
11285 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
11286         if err := pcall(func() {
11287                 ((*(*(struct {
11288                         Param HotbarParam
11289
11290                         //mt:if %s.Param == HotbarSize
11291                         //mt:const uint16(4) // Size of Size field.
11292                         Size int32
11293
11294                         //mt:if %s.Param != HotbarSize
11295                         Img Texture
11296                 }))(obj)).Param).deserialize(r)
11297         }); err != nil {
11298                 if err == io.EOF {
11299                         chk(io.EOF)
11300                 }
11301                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11302         }
11303         if (*(*(struct {
11304                 Param HotbarParam
11305
11306                 //mt:if %s.Param == HotbarSize
11307                 //mt:const uint16(4) // Size of Size field.
11308                 Size int32
11309
11310                 //mt:if %s.Param != HotbarSize
11311                 Img Texture
11312         }))(obj)).Param == HotbarSize {
11313                 {
11314                         var local189 uint16
11315                         local190 := uint16(4) // Size of Size field.
11316                         {
11317                                 p := &local189
11318                                 *p = read16(r)
11319                         }
11320                         if local189 != local190 {
11321                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local189))
11322                         }
11323                 }
11324                 {
11325                         p := &(*(*(struct {
11326                                 Param HotbarParam
11327
11328                                 //mt:if %s.Param == HotbarSize
11329                                 //mt:const uint16(4) // Size of Size field.
11330                                 Size int32
11331
11332                                 //mt:if %s.Param != HotbarSize
11333                                 Img Texture
11334                         }))(obj)).Size
11335                         *p = int32(read32(r))
11336                 }
11337         }
11338         if (*(*(struct {
11339                 Param HotbarParam
11340
11341                 //mt:if %s.Param == HotbarSize
11342                 //mt:const uint16(4) // Size of Size field.
11343                 Size int32
11344
11345                 //mt:if %s.Param != HotbarSize
11346                 Img Texture
11347         }))(obj)).Param != HotbarSize {
11348                 if err := pcall(func() {
11349                         ((*(*(struct {
11350                                 Param HotbarParam
11351
11352                                 //mt:if %s.Param == HotbarSize
11353                                 //mt:const uint16(4) // Size of Size field.
11354                                 Size int32
11355
11356                                 //mt:if %s.Param != HotbarSize
11357                                 Img Texture
11358                         }))(obj)).Img).deserialize(r)
11359                 }); err != nil {
11360                         if err == io.EOF {
11361                                 chk(io.EOF)
11362                         }
11363                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11364                 }
11365         }
11366 }
11367
11368 func (obj *ToCltBreath) serialize(w io.Writer) {
11369         {
11370                 x := (*(*(struct {
11371                         Breath uint16
11372                 }))(obj)).Breath
11373                 write16(w, uint16(x))
11374         }
11375 }
11376
11377 func (obj *ToCltBreath) deserialize(r io.Reader) {
11378         {
11379                 p := &(*(*(struct {
11380                         Breath uint16
11381                 }))(obj)).Breath
11382                 *p = read16(r)
11383         }
11384 }
11385
11386 func (obj *ToCltSkyParams) serialize(w io.Writer) {
11387         {
11388                 x := (*(*(struct {
11389                         BgColor     color.NRGBA
11390                         Type        string
11391                         Clouds      bool
11392                         SunFogTint  color.NRGBA
11393                         MoonFogTint color.NRGBA
11394                         FogTintType string
11395
11396                         //mt:if %s.Type == "skybox"
11397                         Textures []Texture
11398
11399                         //mt:if %s.Type == "regular"
11400                         DaySky, DayHorizon,
11401                         DawnSky, DawnHorizon,
11402                         NightSky, NightHorizon,
11403                         Indoor color.NRGBA
11404                 }))(obj)).BgColor
11405                 w.Write([]byte{x.A, x.R, x.G, x.B})
11406         }
11407         if len(([]byte((*(*(struct {
11408                 BgColor     color.NRGBA
11409                 Type        string
11410                 Clouds      bool
11411                 SunFogTint  color.NRGBA
11412                 MoonFogTint color.NRGBA
11413                 FogTintType string
11414
11415                 //mt:if %s.Type == "skybox"
11416                 Textures []Texture
11417
11418                 //mt:if %s.Type == "regular"
11419                 DaySky, DayHorizon,
11420                 DawnSky, DawnHorizon,
11421                 NightSky, NightHorizon,
11422                 Indoor color.NRGBA
11423         }))(obj)).Type))) > math.MaxUint16 {
11424                 chk(ErrTooLong)
11425         }
11426         {
11427                 x := uint16(len(([]byte((*(*(struct {
11428                         BgColor     color.NRGBA
11429                         Type        string
11430                         Clouds      bool
11431                         SunFogTint  color.NRGBA
11432                         MoonFogTint color.NRGBA
11433                         FogTintType string
11434
11435                         //mt:if %s.Type == "skybox"
11436                         Textures []Texture
11437
11438                         //mt:if %s.Type == "regular"
11439                         DaySky, DayHorizon,
11440                         DawnSky, DawnHorizon,
11441                         NightSky, NightHorizon,
11442                         Indoor color.NRGBA
11443                 }))(obj)).Type))))
11444                 write16(w, uint16(x))
11445         }
11446         {
11447                 _, err := w.Write(([]byte((*(*(struct {
11448                         BgColor     color.NRGBA
11449                         Type        string
11450                         Clouds      bool
11451                         SunFogTint  color.NRGBA
11452                         MoonFogTint color.NRGBA
11453                         FogTintType string
11454
11455                         //mt:if %s.Type == "skybox"
11456                         Textures []Texture
11457
11458                         //mt:if %s.Type == "regular"
11459                         DaySky, DayHorizon,
11460                         DawnSky, DawnHorizon,
11461                         NightSky, NightHorizon,
11462                         Indoor color.NRGBA
11463                 }))(obj)).Type))[:])
11464                 chk(err)
11465         }
11466         {
11467                 x := (*(*(struct {
11468                         BgColor     color.NRGBA
11469                         Type        string
11470                         Clouds      bool
11471                         SunFogTint  color.NRGBA
11472                         MoonFogTint color.NRGBA
11473                         FogTintType string
11474
11475                         //mt:if %s.Type == "skybox"
11476                         Textures []Texture
11477
11478                         //mt:if %s.Type == "regular"
11479                         DaySky, DayHorizon,
11480                         DawnSky, DawnHorizon,
11481                         NightSky, NightHorizon,
11482                         Indoor color.NRGBA
11483                 }))(obj)).Clouds
11484                 if x {
11485                         write8(w, 1)
11486                 } else {
11487                         write8(w, 0)
11488                 }
11489         }
11490         {
11491                 x := (*(*(struct {
11492                         BgColor     color.NRGBA
11493                         Type        string
11494                         Clouds      bool
11495                         SunFogTint  color.NRGBA
11496                         MoonFogTint color.NRGBA
11497                         FogTintType string
11498
11499                         //mt:if %s.Type == "skybox"
11500                         Textures []Texture
11501
11502                         //mt:if %s.Type == "regular"
11503                         DaySky, DayHorizon,
11504                         DawnSky, DawnHorizon,
11505                         NightSky, NightHorizon,
11506                         Indoor color.NRGBA
11507                 }))(obj)).SunFogTint
11508                 w.Write([]byte{x.A, x.R, x.G, x.B})
11509         }
11510         {
11511                 x := (*(*(struct {
11512                         BgColor     color.NRGBA
11513                         Type        string
11514                         Clouds      bool
11515                         SunFogTint  color.NRGBA
11516                         MoonFogTint color.NRGBA
11517                         FogTintType string
11518
11519                         //mt:if %s.Type == "skybox"
11520                         Textures []Texture
11521
11522                         //mt:if %s.Type == "regular"
11523                         DaySky, DayHorizon,
11524                         DawnSky, DawnHorizon,
11525                         NightSky, NightHorizon,
11526                         Indoor color.NRGBA
11527                 }))(obj)).MoonFogTint
11528                 w.Write([]byte{x.A, x.R, x.G, x.B})
11529         }
11530         if len(([]byte((*(*(struct {
11531                 BgColor     color.NRGBA
11532                 Type        string
11533                 Clouds      bool
11534                 SunFogTint  color.NRGBA
11535                 MoonFogTint color.NRGBA
11536                 FogTintType string
11537
11538                 //mt:if %s.Type == "skybox"
11539                 Textures []Texture
11540
11541                 //mt:if %s.Type == "regular"
11542                 DaySky, DayHorizon,
11543                 DawnSky, DawnHorizon,
11544                 NightSky, NightHorizon,
11545                 Indoor color.NRGBA
11546         }))(obj)).FogTintType))) > math.MaxUint16 {
11547                 chk(ErrTooLong)
11548         }
11549         {
11550                 x := uint16(len(([]byte((*(*(struct {
11551                         BgColor     color.NRGBA
11552                         Type        string
11553                         Clouds      bool
11554                         SunFogTint  color.NRGBA
11555                         MoonFogTint color.NRGBA
11556                         FogTintType string
11557
11558                         //mt:if %s.Type == "skybox"
11559                         Textures []Texture
11560
11561                         //mt:if %s.Type == "regular"
11562                         DaySky, DayHorizon,
11563                         DawnSky, DawnHorizon,
11564                         NightSky, NightHorizon,
11565                         Indoor color.NRGBA
11566                 }))(obj)).FogTintType))))
11567                 write16(w, uint16(x))
11568         }
11569         {
11570                 _, err := w.Write(([]byte((*(*(struct {
11571                         BgColor     color.NRGBA
11572                         Type        string
11573                         Clouds      bool
11574                         SunFogTint  color.NRGBA
11575                         MoonFogTint color.NRGBA
11576                         FogTintType string
11577
11578                         //mt:if %s.Type == "skybox"
11579                         Textures []Texture
11580
11581                         //mt:if %s.Type == "regular"
11582                         DaySky, DayHorizon,
11583                         DawnSky, DawnHorizon,
11584                         NightSky, NightHorizon,
11585                         Indoor color.NRGBA
11586                 }))(obj)).FogTintType))[:])
11587                 chk(err)
11588         }
11589         if (*(*(struct {
11590                 BgColor     color.NRGBA
11591                 Type        string
11592                 Clouds      bool
11593                 SunFogTint  color.NRGBA
11594                 MoonFogTint color.NRGBA
11595                 FogTintType string
11596
11597                 //mt:if %s.Type == "skybox"
11598                 Textures []Texture
11599
11600                 //mt:if %s.Type == "regular"
11601                 DaySky, DayHorizon,
11602                 DawnSky, DawnHorizon,
11603                 NightSky, NightHorizon,
11604                 Indoor color.NRGBA
11605         }))(obj)).Type == "skybox" {
11606                 if len(((*(*(struct {
11607                         BgColor     color.NRGBA
11608                         Type        string
11609                         Clouds      bool
11610                         SunFogTint  color.NRGBA
11611                         MoonFogTint color.NRGBA
11612                         FogTintType string
11613
11614                         //mt:if %s.Type == "skybox"
11615                         Textures []Texture
11616
11617                         //mt:if %s.Type == "regular"
11618                         DaySky, DayHorizon,
11619                         DawnSky, DawnHorizon,
11620                         NightSky, NightHorizon,
11621                         Indoor color.NRGBA
11622                 }))(obj)).Textures)) > math.MaxUint16 {
11623                         chk(ErrTooLong)
11624                 }
11625                 {
11626                         x := uint16(len(((*(*(struct {
11627                                 BgColor     color.NRGBA
11628                                 Type        string
11629                                 Clouds      bool
11630                                 SunFogTint  color.NRGBA
11631                                 MoonFogTint color.NRGBA
11632                                 FogTintType string
11633
11634                                 //mt:if %s.Type == "skybox"
11635                                 Textures []Texture
11636
11637                                 //mt:if %s.Type == "regular"
11638                                 DaySky, DayHorizon,
11639                                 DawnSky, DawnHorizon,
11640                                 NightSky, NightHorizon,
11641                                 Indoor color.NRGBA
11642                         }))(obj)).Textures)))
11643                         write16(w, uint16(x))
11644                 }
11645                 for local191 := range (*(*(struct {
11646                         BgColor     color.NRGBA
11647                         Type        string
11648                         Clouds      bool
11649                         SunFogTint  color.NRGBA
11650                         MoonFogTint color.NRGBA
11651                         FogTintType string
11652
11653                         //mt:if %s.Type == "skybox"
11654                         Textures []Texture
11655
11656                         //mt:if %s.Type == "regular"
11657                         DaySky, DayHorizon,
11658                         DawnSky, DawnHorizon,
11659                         NightSky, NightHorizon,
11660                         Indoor color.NRGBA
11661                 }))(obj)).Textures {
11662                         if err := pcall(func() {
11663                                 (((*(*(struct {
11664                                         BgColor     color.NRGBA
11665                                         Type        string
11666                                         Clouds      bool
11667                                         SunFogTint  color.NRGBA
11668                                         MoonFogTint color.NRGBA
11669                                         FogTintType string
11670
11671                                         //mt:if %s.Type == "skybox"
11672                                         Textures []Texture
11673
11674                                         //mt:if %s.Type == "regular"
11675                                         DaySky, DayHorizon,
11676                                         DawnSky, DawnHorizon,
11677                                         NightSky, NightHorizon,
11678                                         Indoor color.NRGBA
11679                                 }))(obj)).Textures)[local191]).serialize(w)
11680                         }); err != nil {
11681                                 if err == io.EOF {
11682                                         chk(io.EOF)
11683                                 }
11684                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11685                         }
11686                 }
11687         }
11688         if (*(*(struct {
11689                 BgColor     color.NRGBA
11690                 Type        string
11691                 Clouds      bool
11692                 SunFogTint  color.NRGBA
11693                 MoonFogTint color.NRGBA
11694                 FogTintType string
11695
11696                 //mt:if %s.Type == "skybox"
11697                 Textures []Texture
11698
11699                 //mt:if %s.Type == "regular"
11700                 DaySky, DayHorizon,
11701                 DawnSky, DawnHorizon,
11702                 NightSky, NightHorizon,
11703                 Indoor color.NRGBA
11704         }))(obj)).Type == "regular" {
11705                 {
11706                         x := (*(*(struct {
11707                                 BgColor     color.NRGBA
11708                                 Type        string
11709                                 Clouds      bool
11710                                 SunFogTint  color.NRGBA
11711                                 MoonFogTint color.NRGBA
11712                                 FogTintType string
11713
11714                                 //mt:if %s.Type == "skybox"
11715                                 Textures []Texture
11716
11717                                 //mt:if %s.Type == "regular"
11718                                 DaySky, DayHorizon,
11719                                 DawnSky, DawnHorizon,
11720                                 NightSky, NightHorizon,
11721                                 Indoor color.NRGBA
11722                         }))(obj)).DaySky
11723                         w.Write([]byte{x.A, x.R, x.G, x.B})
11724                 }
11725                 {
11726                         x := (*(*(struct {
11727                                 BgColor     color.NRGBA
11728                                 Type        string
11729                                 Clouds      bool
11730                                 SunFogTint  color.NRGBA
11731                                 MoonFogTint color.NRGBA
11732                                 FogTintType string
11733
11734                                 //mt:if %s.Type == "skybox"
11735                                 Textures []Texture
11736
11737                                 //mt:if %s.Type == "regular"
11738                                 DaySky, DayHorizon,
11739                                 DawnSky, DawnHorizon,
11740                                 NightSky, NightHorizon,
11741                                 Indoor color.NRGBA
11742                         }))(obj)).DayHorizon
11743                         w.Write([]byte{x.A, x.R, x.G, x.B})
11744                 }
11745                 {
11746                         x := (*(*(struct {
11747                                 BgColor     color.NRGBA
11748                                 Type        string
11749                                 Clouds      bool
11750                                 SunFogTint  color.NRGBA
11751                                 MoonFogTint color.NRGBA
11752                                 FogTintType string
11753
11754                                 //mt:if %s.Type == "skybox"
11755                                 Textures []Texture
11756
11757                                 //mt:if %s.Type == "regular"
11758                                 DaySky, DayHorizon,
11759                                 DawnSky, DawnHorizon,
11760                                 NightSky, NightHorizon,
11761                                 Indoor color.NRGBA
11762                         }))(obj)).DawnSky
11763                         w.Write([]byte{x.A, x.R, x.G, x.B})
11764                 }
11765                 {
11766                         x := (*(*(struct {
11767                                 BgColor     color.NRGBA
11768                                 Type        string
11769                                 Clouds      bool
11770                                 SunFogTint  color.NRGBA
11771                                 MoonFogTint color.NRGBA
11772                                 FogTintType string
11773
11774                                 //mt:if %s.Type == "skybox"
11775                                 Textures []Texture
11776
11777                                 //mt:if %s.Type == "regular"
11778                                 DaySky, DayHorizon,
11779                                 DawnSky, DawnHorizon,
11780                                 NightSky, NightHorizon,
11781                                 Indoor color.NRGBA
11782                         }))(obj)).DawnHorizon
11783                         w.Write([]byte{x.A, x.R, x.G, x.B})
11784                 }
11785                 {
11786                         x := (*(*(struct {
11787                                 BgColor     color.NRGBA
11788                                 Type        string
11789                                 Clouds      bool
11790                                 SunFogTint  color.NRGBA
11791                                 MoonFogTint color.NRGBA
11792                                 FogTintType string
11793
11794                                 //mt:if %s.Type == "skybox"
11795                                 Textures []Texture
11796
11797                                 //mt:if %s.Type == "regular"
11798                                 DaySky, DayHorizon,
11799                                 DawnSky, DawnHorizon,
11800                                 NightSky, NightHorizon,
11801                                 Indoor color.NRGBA
11802                         }))(obj)).NightSky
11803                         w.Write([]byte{x.A, x.R, x.G, x.B})
11804                 }
11805                 {
11806                         x := (*(*(struct {
11807                                 BgColor     color.NRGBA
11808                                 Type        string
11809                                 Clouds      bool
11810                                 SunFogTint  color.NRGBA
11811                                 MoonFogTint color.NRGBA
11812                                 FogTintType string
11813
11814                                 //mt:if %s.Type == "skybox"
11815                                 Textures []Texture
11816
11817                                 //mt:if %s.Type == "regular"
11818                                 DaySky, DayHorizon,
11819                                 DawnSky, DawnHorizon,
11820                                 NightSky, NightHorizon,
11821                                 Indoor color.NRGBA
11822                         }))(obj)).NightHorizon
11823                         w.Write([]byte{x.A, x.R, x.G, x.B})
11824                 }
11825                 {
11826                         x := (*(*(struct {
11827                                 BgColor     color.NRGBA
11828                                 Type        string
11829                                 Clouds      bool
11830                                 SunFogTint  color.NRGBA
11831                                 MoonFogTint color.NRGBA
11832                                 FogTintType string
11833
11834                                 //mt:if %s.Type == "skybox"
11835                                 Textures []Texture
11836
11837                                 //mt:if %s.Type == "regular"
11838                                 DaySky, DayHorizon,
11839                                 DawnSky, DawnHorizon,
11840                                 NightSky, NightHorizon,
11841                                 Indoor color.NRGBA
11842                         }))(obj)).Indoor
11843                         w.Write([]byte{x.A, x.R, x.G, x.B})
11844                 }
11845         }
11846 }
11847
11848 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
11849         {
11850                 p := &(*(*(struct {
11851                         BgColor     color.NRGBA
11852                         Type        string
11853                         Clouds      bool
11854                         SunFogTint  color.NRGBA
11855                         MoonFogTint color.NRGBA
11856                         FogTintType string
11857
11858                         //mt:if %s.Type == "skybox"
11859                         Textures []Texture
11860
11861                         //mt:if %s.Type == "regular"
11862                         DaySky, DayHorizon,
11863                         DawnSky, DawnHorizon,
11864                         NightSky, NightHorizon,
11865                         Indoor color.NRGBA
11866                 }))(obj)).BgColor
11867                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11868         }
11869         var local192 []uint8
11870         var local193 uint16
11871         {
11872                 p := &local193
11873                 *p = read16(r)
11874         }
11875         (local192) = make([]uint8, local193)
11876         {
11877                 _, err := io.ReadFull(r, (local192)[:])
11878                 chk(err)
11879         }
11880         ((*(*(struct {
11881                 BgColor     color.NRGBA
11882                 Type        string
11883                 Clouds      bool
11884                 SunFogTint  color.NRGBA
11885                 MoonFogTint color.NRGBA
11886                 FogTintType string
11887
11888                 //mt:if %s.Type == "skybox"
11889                 Textures []Texture
11890
11891                 //mt:if %s.Type == "regular"
11892                 DaySky, DayHorizon,
11893                 DawnSky, DawnHorizon,
11894                 NightSky, NightHorizon,
11895                 Indoor color.NRGBA
11896         }))(obj)).Type) = string(local192)
11897         {
11898                 p := &(*(*(struct {
11899                         BgColor     color.NRGBA
11900                         Type        string
11901                         Clouds      bool
11902                         SunFogTint  color.NRGBA
11903                         MoonFogTint color.NRGBA
11904                         FogTintType string
11905
11906                         //mt:if %s.Type == "skybox"
11907                         Textures []Texture
11908
11909                         //mt:if %s.Type == "regular"
11910                         DaySky, DayHorizon,
11911                         DawnSky, DawnHorizon,
11912                         NightSky, NightHorizon,
11913                         Indoor color.NRGBA
11914                 }))(obj)).Clouds
11915                 switch n := read8(r); n {
11916                 case 0:
11917                         *p = false
11918                 case 1:
11919                         *p = true
11920                 default:
11921                         chk(fmt.Errorf("invalid bool: %d", n))
11922                 }
11923         }
11924         {
11925                 p := &(*(*(struct {
11926                         BgColor     color.NRGBA
11927                         Type        string
11928                         Clouds      bool
11929                         SunFogTint  color.NRGBA
11930                         MoonFogTint color.NRGBA
11931                         FogTintType string
11932
11933                         //mt:if %s.Type == "skybox"
11934                         Textures []Texture
11935
11936                         //mt:if %s.Type == "regular"
11937                         DaySky, DayHorizon,
11938                         DawnSky, DawnHorizon,
11939                         NightSky, NightHorizon,
11940                         Indoor color.NRGBA
11941                 }))(obj)).SunFogTint
11942                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11943         }
11944         {
11945                 p := &(*(*(struct {
11946                         BgColor     color.NRGBA
11947                         Type        string
11948                         Clouds      bool
11949                         SunFogTint  color.NRGBA
11950                         MoonFogTint color.NRGBA
11951                         FogTintType string
11952
11953                         //mt:if %s.Type == "skybox"
11954                         Textures []Texture
11955
11956                         //mt:if %s.Type == "regular"
11957                         DaySky, DayHorizon,
11958                         DawnSky, DawnHorizon,
11959                         NightSky, NightHorizon,
11960                         Indoor color.NRGBA
11961                 }))(obj)).MoonFogTint
11962                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11963         }
11964         var local194 []uint8
11965         var local195 uint16
11966         {
11967                 p := &local195
11968                 *p = read16(r)
11969         }
11970         (local194) = make([]uint8, local195)
11971         {
11972                 _, err := io.ReadFull(r, (local194)[:])
11973                 chk(err)
11974         }
11975         ((*(*(struct {
11976                 BgColor     color.NRGBA
11977                 Type        string
11978                 Clouds      bool
11979                 SunFogTint  color.NRGBA
11980                 MoonFogTint color.NRGBA
11981                 FogTintType string
11982
11983                 //mt:if %s.Type == "skybox"
11984                 Textures []Texture
11985
11986                 //mt:if %s.Type == "regular"
11987                 DaySky, DayHorizon,
11988                 DawnSky, DawnHorizon,
11989                 NightSky, NightHorizon,
11990                 Indoor color.NRGBA
11991         }))(obj)).FogTintType) = string(local194)
11992         if (*(*(struct {
11993                 BgColor     color.NRGBA
11994                 Type        string
11995                 Clouds      bool
11996                 SunFogTint  color.NRGBA
11997                 MoonFogTint color.NRGBA
11998                 FogTintType string
11999
12000                 //mt:if %s.Type == "skybox"
12001                 Textures []Texture
12002
12003                 //mt:if %s.Type == "regular"
12004                 DaySky, DayHorizon,
12005                 DawnSky, DawnHorizon,
12006                 NightSky, NightHorizon,
12007                 Indoor color.NRGBA
12008         }))(obj)).Type == "skybox" {
12009                 var local196 uint16
12010                 {
12011                         p := &local196
12012                         *p = read16(r)
12013                 }
12014                 ((*(*(struct {
12015                         BgColor     color.NRGBA
12016                         Type        string
12017                         Clouds      bool
12018                         SunFogTint  color.NRGBA
12019                         MoonFogTint color.NRGBA
12020                         FogTintType string
12021
12022                         //mt:if %s.Type == "skybox"
12023                         Textures []Texture
12024
12025                         //mt:if %s.Type == "regular"
12026                         DaySky, DayHorizon,
12027                         DawnSky, DawnHorizon,
12028                         NightSky, NightHorizon,
12029                         Indoor color.NRGBA
12030                 }))(obj)).Textures) = make([]Texture, local196)
12031                 for local197 := range (*(*(struct {
12032                         BgColor     color.NRGBA
12033                         Type        string
12034                         Clouds      bool
12035                         SunFogTint  color.NRGBA
12036                         MoonFogTint color.NRGBA
12037                         FogTintType string
12038
12039                         //mt:if %s.Type == "skybox"
12040                         Textures []Texture
12041
12042                         //mt:if %s.Type == "regular"
12043                         DaySky, DayHorizon,
12044                         DawnSky, DawnHorizon,
12045                         NightSky, NightHorizon,
12046                         Indoor color.NRGBA
12047                 }))(obj)).Textures {
12048                         if err := pcall(func() {
12049                                 (((*(*(struct {
12050                                         BgColor     color.NRGBA
12051                                         Type        string
12052                                         Clouds      bool
12053                                         SunFogTint  color.NRGBA
12054                                         MoonFogTint color.NRGBA
12055                                         FogTintType string
12056
12057                                         //mt:if %s.Type == "skybox"
12058                                         Textures []Texture
12059
12060                                         //mt:if %s.Type == "regular"
12061                                         DaySky, DayHorizon,
12062                                         DawnSky, DawnHorizon,
12063                                         NightSky, NightHorizon,
12064                                         Indoor color.NRGBA
12065                                 }))(obj)).Textures)[local197]).deserialize(r)
12066                         }); err != nil {
12067                                 if err == io.EOF {
12068                                         chk(io.EOF)
12069                                 }
12070                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
12071                         }
12072                 }
12073         }
12074         if (*(*(struct {
12075                 BgColor     color.NRGBA
12076                 Type        string
12077                 Clouds      bool
12078                 SunFogTint  color.NRGBA
12079                 MoonFogTint color.NRGBA
12080                 FogTintType string
12081
12082                 //mt:if %s.Type == "skybox"
12083                 Textures []Texture
12084
12085                 //mt:if %s.Type == "regular"
12086                 DaySky, DayHorizon,
12087                 DawnSky, DawnHorizon,
12088                 NightSky, NightHorizon,
12089                 Indoor color.NRGBA
12090         }))(obj)).Type == "regular" {
12091                 {
12092                         p := &(*(*(struct {
12093                                 BgColor     color.NRGBA
12094                                 Type        string
12095                                 Clouds      bool
12096                                 SunFogTint  color.NRGBA
12097                                 MoonFogTint color.NRGBA
12098                                 FogTintType string
12099
12100                                 //mt:if %s.Type == "skybox"
12101                                 Textures []Texture
12102
12103                                 //mt:if %s.Type == "regular"
12104                                 DaySky, DayHorizon,
12105                                 DawnSky, DawnHorizon,
12106                                 NightSky, NightHorizon,
12107                                 Indoor color.NRGBA
12108                         }))(obj)).DaySky
12109                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12110                 }
12111                 {
12112                         p := &(*(*(struct {
12113                                 BgColor     color.NRGBA
12114                                 Type        string
12115                                 Clouds      bool
12116                                 SunFogTint  color.NRGBA
12117                                 MoonFogTint color.NRGBA
12118                                 FogTintType string
12119
12120                                 //mt:if %s.Type == "skybox"
12121                                 Textures []Texture
12122
12123                                 //mt:if %s.Type == "regular"
12124                                 DaySky, DayHorizon,
12125                                 DawnSky, DawnHorizon,
12126                                 NightSky, NightHorizon,
12127                                 Indoor color.NRGBA
12128                         }))(obj)).DayHorizon
12129                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12130                 }
12131                 {
12132                         p := &(*(*(struct {
12133                                 BgColor     color.NRGBA
12134                                 Type        string
12135                                 Clouds      bool
12136                                 SunFogTint  color.NRGBA
12137                                 MoonFogTint color.NRGBA
12138                                 FogTintType string
12139
12140                                 //mt:if %s.Type == "skybox"
12141                                 Textures []Texture
12142
12143                                 //mt:if %s.Type == "regular"
12144                                 DaySky, DayHorizon,
12145                                 DawnSky, DawnHorizon,
12146                                 NightSky, NightHorizon,
12147                                 Indoor color.NRGBA
12148                         }))(obj)).DawnSky
12149                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12150                 }
12151                 {
12152                         p := &(*(*(struct {
12153                                 BgColor     color.NRGBA
12154                                 Type        string
12155                                 Clouds      bool
12156                                 SunFogTint  color.NRGBA
12157                                 MoonFogTint color.NRGBA
12158                                 FogTintType string
12159
12160                                 //mt:if %s.Type == "skybox"
12161                                 Textures []Texture
12162
12163                                 //mt:if %s.Type == "regular"
12164                                 DaySky, DayHorizon,
12165                                 DawnSky, DawnHorizon,
12166                                 NightSky, NightHorizon,
12167                                 Indoor color.NRGBA
12168                         }))(obj)).DawnHorizon
12169                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12170                 }
12171                 {
12172                         p := &(*(*(struct {
12173                                 BgColor     color.NRGBA
12174                                 Type        string
12175                                 Clouds      bool
12176                                 SunFogTint  color.NRGBA
12177                                 MoonFogTint color.NRGBA
12178                                 FogTintType string
12179
12180                                 //mt:if %s.Type == "skybox"
12181                                 Textures []Texture
12182
12183                                 //mt:if %s.Type == "regular"
12184                                 DaySky, DayHorizon,
12185                                 DawnSky, DawnHorizon,
12186                                 NightSky, NightHorizon,
12187                                 Indoor color.NRGBA
12188                         }))(obj)).NightSky
12189                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12190                 }
12191                 {
12192                         p := &(*(*(struct {
12193                                 BgColor     color.NRGBA
12194                                 Type        string
12195                                 Clouds      bool
12196                                 SunFogTint  color.NRGBA
12197                                 MoonFogTint color.NRGBA
12198                                 FogTintType string
12199
12200                                 //mt:if %s.Type == "skybox"
12201                                 Textures []Texture
12202
12203                                 //mt:if %s.Type == "regular"
12204                                 DaySky, DayHorizon,
12205                                 DawnSky, DawnHorizon,
12206                                 NightSky, NightHorizon,
12207                                 Indoor color.NRGBA
12208                         }))(obj)).NightHorizon
12209                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12210                 }
12211                 {
12212                         p := &(*(*(struct {
12213                                 BgColor     color.NRGBA
12214                                 Type        string
12215                                 Clouds      bool
12216                                 SunFogTint  color.NRGBA
12217                                 MoonFogTint color.NRGBA
12218                                 FogTintType string
12219
12220                                 //mt:if %s.Type == "skybox"
12221                                 Textures []Texture
12222
12223                                 //mt:if %s.Type == "regular"
12224                                 DaySky, DayHorizon,
12225                                 DawnSky, DawnHorizon,
12226                                 NightSky, NightHorizon,
12227                                 Indoor color.NRGBA
12228                         }))(obj)).Indoor
12229                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12230                 }
12231         }
12232 }
12233
12234 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
12235         {
12236                 x := (*(*(struct {
12237                         Override bool
12238                         Ratio    uint16
12239                 }))(obj)).Override
12240                 if x {
12241                         write8(w, 1)
12242                 } else {
12243                         write8(w, 0)
12244                 }
12245         }
12246         {
12247                 x := (*(*(struct {
12248                         Override bool
12249                         Ratio    uint16
12250                 }))(obj)).Ratio
12251                 write16(w, uint16(x))
12252         }
12253 }
12254
12255 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
12256         {
12257                 p := &(*(*(struct {
12258                         Override bool
12259                         Ratio    uint16
12260                 }))(obj)).Override
12261                 switch n := read8(r); n {
12262                 case 0:
12263                         *p = false
12264                 case 1:
12265                         *p = true
12266                 default:
12267                         chk(fmt.Errorf("invalid bool: %d", n))
12268                 }
12269         }
12270         {
12271                 p := &(*(*(struct {
12272                         Override bool
12273                         Ratio    uint16
12274                 }))(obj)).Ratio
12275                 *p = read16(r)
12276         }
12277 }
12278
12279 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
12280         for local198 := range (*(*(struct {
12281                 Idle, Walk, Dig, WalkDig [2]int32
12282                 Speed                    float32
12283         }))(obj)).Idle {
12284                 {
12285                         x := ((*(*(struct {
12286                                 Idle, Walk, Dig, WalkDig [2]int32
12287                                 Speed                    float32
12288                         }))(obj)).Idle)[local198]
12289                         write32(w, uint32(x))
12290                 }
12291         }
12292         for local199 := range (*(*(struct {
12293                 Idle, Walk, Dig, WalkDig [2]int32
12294                 Speed                    float32
12295         }))(obj)).Walk {
12296                 {
12297                         x := ((*(*(struct {
12298                                 Idle, Walk, Dig, WalkDig [2]int32
12299                                 Speed                    float32
12300                         }))(obj)).Walk)[local199]
12301                         write32(w, uint32(x))
12302                 }
12303         }
12304         for local200 := range (*(*(struct {
12305                 Idle, Walk, Dig, WalkDig [2]int32
12306                 Speed                    float32
12307         }))(obj)).Dig {
12308                 {
12309                         x := ((*(*(struct {
12310                                 Idle, Walk, Dig, WalkDig [2]int32
12311                                 Speed                    float32
12312                         }))(obj)).Dig)[local200]
12313                         write32(w, uint32(x))
12314                 }
12315         }
12316         for local201 := range (*(*(struct {
12317                 Idle, Walk, Dig, WalkDig [2]int32
12318                 Speed                    float32
12319         }))(obj)).WalkDig {
12320                 {
12321                         x := ((*(*(struct {
12322                                 Idle, Walk, Dig, WalkDig [2]int32
12323                                 Speed                    float32
12324                         }))(obj)).WalkDig)[local201]
12325                         write32(w, uint32(x))
12326                 }
12327         }
12328         {
12329                 x := (*(*(struct {
12330                         Idle, Walk, Dig, WalkDig [2]int32
12331                         Speed                    float32
12332                 }))(obj)).Speed
12333                 write32(w, math.Float32bits(x))
12334         }
12335 }
12336
12337 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
12338         for local202 := range (*(*(struct {
12339                 Idle, Walk, Dig, WalkDig [2]int32
12340                 Speed                    float32
12341         }))(obj)).Idle {
12342                 {
12343                         p := &((*(*(struct {
12344                                 Idle, Walk, Dig, WalkDig [2]int32
12345                                 Speed                    float32
12346                         }))(obj)).Idle)[local202]
12347                         *p = int32(read32(r))
12348                 }
12349         }
12350         for local203 := range (*(*(struct {
12351                 Idle, Walk, Dig, WalkDig [2]int32
12352                 Speed                    float32
12353         }))(obj)).Walk {
12354                 {
12355                         p := &((*(*(struct {
12356                                 Idle, Walk, Dig, WalkDig [2]int32
12357                                 Speed                    float32
12358                         }))(obj)).Walk)[local203]
12359                         *p = int32(read32(r))
12360                 }
12361         }
12362         for local204 := range (*(*(struct {
12363                 Idle, Walk, Dig, WalkDig [2]int32
12364                 Speed                    float32
12365         }))(obj)).Dig {
12366                 {
12367                         p := &((*(*(struct {
12368                                 Idle, Walk, Dig, WalkDig [2]int32
12369                                 Speed                    float32
12370                         }))(obj)).Dig)[local204]
12371                         *p = int32(read32(r))
12372                 }
12373         }
12374         for local205 := range (*(*(struct {
12375                 Idle, Walk, Dig, WalkDig [2]int32
12376                 Speed                    float32
12377         }))(obj)).WalkDig {
12378                 {
12379                         p := &((*(*(struct {
12380                                 Idle, Walk, Dig, WalkDig [2]int32
12381                                 Speed                    float32
12382                         }))(obj)).WalkDig)[local205]
12383                         *p = int32(read32(r))
12384                 }
12385         }
12386         {
12387                 p := &(*(*(struct {
12388                         Idle, Walk, Dig, WalkDig [2]int32
12389                         Speed                    float32
12390                 }))(obj)).Speed
12391                 *p = math.Float32frombits(read32(r))
12392         }
12393 }
12394
12395 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
12396         if err := pcall(func() {
12397                 ((*(*(struct {
12398                         First, Third Vec
12399                 }))(obj)).First).serialize(w)
12400         }); err != nil {
12401                 if err == io.EOF {
12402                         chk(io.EOF)
12403                 }
12404                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12405         }
12406         if err := pcall(func() {
12407                 ((*(*(struct {
12408                         First, Third Vec
12409                 }))(obj)).Third).serialize(w)
12410         }); err != nil {
12411                 if err == io.EOF {
12412                         chk(io.EOF)
12413                 }
12414                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12415         }
12416 }
12417
12418 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
12419         if err := pcall(func() {
12420                 ((*(*(struct {
12421                         First, Third Vec
12422                 }))(obj)).First).deserialize(r)
12423         }); err != nil {
12424                 if err == io.EOF {
12425                         chk(io.EOF)
12426                 }
12427                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12428         }
12429         if err := pcall(func() {
12430                 ((*(*(struct {
12431                         First, Third Vec
12432                 }))(obj)).Third).deserialize(r)
12433         }); err != nil {
12434                 if err == io.EOF {
12435                         chk(io.EOF)
12436                 }
12437                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12438         }
12439 }
12440
12441 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
12442         if err := pcall(func() {
12443                 ((*(*(struct {
12444                         ID ParticleSpawnerID
12445                 }))(obj)).ID).serialize(w)
12446         }); err != nil {
12447                 if err == io.EOF {
12448                         chk(io.EOF)
12449                 }
12450                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12451         }
12452 }
12453
12454 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
12455         if err := pcall(func() {
12456                 ((*(*(struct {
12457                         ID ParticleSpawnerID
12458                 }))(obj)).ID).deserialize(r)
12459         }); err != nil {
12460                 if err == io.EOF {
12461                         chk(io.EOF)
12462                 }
12463                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12464         }
12465 }
12466
12467 func (obj *ToCltCloudParams) serialize(w io.Writer) {
12468         {
12469                 x := (*(*(struct {
12470                         Density      float32
12471                         DiffuseColor color.NRGBA
12472                         AmbientColor color.NRGBA
12473                         Height       float32
12474                         Thickness    float32
12475                         Speed        [2]float32
12476                 }))(obj)).Density
12477                 write32(w, math.Float32bits(x))
12478         }
12479         {
12480                 x := (*(*(struct {
12481                         Density      float32
12482                         DiffuseColor color.NRGBA
12483                         AmbientColor color.NRGBA
12484                         Height       float32
12485                         Thickness    float32
12486                         Speed        [2]float32
12487                 }))(obj)).DiffuseColor
12488                 w.Write([]byte{x.A, x.R, x.G, x.B})
12489         }
12490         {
12491                 x := (*(*(struct {
12492                         Density      float32
12493                         DiffuseColor color.NRGBA
12494                         AmbientColor color.NRGBA
12495                         Height       float32
12496                         Thickness    float32
12497                         Speed        [2]float32
12498                 }))(obj)).AmbientColor
12499                 w.Write([]byte{x.A, x.R, x.G, x.B})
12500         }
12501         {
12502                 x := (*(*(struct {
12503                         Density      float32
12504                         DiffuseColor color.NRGBA
12505                         AmbientColor color.NRGBA
12506                         Height       float32
12507                         Thickness    float32
12508                         Speed        [2]float32
12509                 }))(obj)).Height
12510                 write32(w, math.Float32bits(x))
12511         }
12512         {
12513                 x := (*(*(struct {
12514                         Density      float32
12515                         DiffuseColor color.NRGBA
12516                         AmbientColor color.NRGBA
12517                         Height       float32
12518                         Thickness    float32
12519                         Speed        [2]float32
12520                 }))(obj)).Thickness
12521                 write32(w, math.Float32bits(x))
12522         }
12523         for local206 := range (*(*(struct {
12524                 Density      float32
12525                 DiffuseColor color.NRGBA
12526                 AmbientColor color.NRGBA
12527                 Height       float32
12528                 Thickness    float32
12529                 Speed        [2]float32
12530         }))(obj)).Speed {
12531                 {
12532                         x := ((*(*(struct {
12533                                 Density      float32
12534                                 DiffuseColor color.NRGBA
12535                                 AmbientColor color.NRGBA
12536                                 Height       float32
12537                                 Thickness    float32
12538                                 Speed        [2]float32
12539                         }))(obj)).Speed)[local206]
12540                         write32(w, math.Float32bits(x))
12541                 }
12542         }
12543 }
12544
12545 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
12546         {
12547                 p := &(*(*(struct {
12548                         Density      float32
12549                         DiffuseColor color.NRGBA
12550                         AmbientColor color.NRGBA
12551                         Height       float32
12552                         Thickness    float32
12553                         Speed        [2]float32
12554                 }))(obj)).Density
12555                 *p = math.Float32frombits(read32(r))
12556         }
12557         {
12558                 p := &(*(*(struct {
12559                         Density      float32
12560                         DiffuseColor color.NRGBA
12561                         AmbientColor color.NRGBA
12562                         Height       float32
12563                         Thickness    float32
12564                         Speed        [2]float32
12565                 }))(obj)).DiffuseColor
12566                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12567         }
12568         {
12569                 p := &(*(*(struct {
12570                         Density      float32
12571                         DiffuseColor color.NRGBA
12572                         AmbientColor color.NRGBA
12573                         Height       float32
12574                         Thickness    float32
12575                         Speed        [2]float32
12576                 }))(obj)).AmbientColor
12577                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12578         }
12579         {
12580                 p := &(*(*(struct {
12581                         Density      float32
12582                         DiffuseColor color.NRGBA
12583                         AmbientColor color.NRGBA
12584                         Height       float32
12585                         Thickness    float32
12586                         Speed        [2]float32
12587                 }))(obj)).Height
12588                 *p = math.Float32frombits(read32(r))
12589         }
12590         {
12591                 p := &(*(*(struct {
12592                         Density      float32
12593                         DiffuseColor color.NRGBA
12594                         AmbientColor color.NRGBA
12595                         Height       float32
12596                         Thickness    float32
12597                         Speed        [2]float32
12598                 }))(obj)).Thickness
12599                 *p = math.Float32frombits(read32(r))
12600         }
12601         for local207 := range (*(*(struct {
12602                 Density      float32
12603                 DiffuseColor color.NRGBA
12604                 AmbientColor color.NRGBA
12605                 Height       float32
12606                 Thickness    float32
12607                 Speed        [2]float32
12608         }))(obj)).Speed {
12609                 {
12610                         p := &((*(*(struct {
12611                                 Density      float32
12612                                 DiffuseColor color.NRGBA
12613                                 AmbientColor color.NRGBA
12614                                 Height       float32
12615                                 Thickness    float32
12616                                 Speed        [2]float32
12617                         }))(obj)).Speed)[local207]
12618                         *p = math.Float32frombits(read32(r))
12619                 }
12620         }
12621 }
12622
12623 func (obj *ToCltFadeSound) serialize(w io.Writer) {
12624         if err := pcall(func() {
12625                 ((*(*(struct {
12626                         ID   SoundID
12627                         Step float32
12628                         Gain float32
12629                 }))(obj)).ID).serialize(w)
12630         }); err != nil {
12631                 if err == io.EOF {
12632                         chk(io.EOF)
12633                 }
12634                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12635         }
12636         {
12637                 x := (*(*(struct {
12638                         ID   SoundID
12639                         Step float32
12640                         Gain float32
12641                 }))(obj)).Step
12642                 write32(w, math.Float32bits(x))
12643         }
12644         {
12645                 x := (*(*(struct {
12646                         ID   SoundID
12647                         Step float32
12648                         Gain float32
12649                 }))(obj)).Gain
12650                 write32(w, math.Float32bits(x))
12651         }
12652 }
12653
12654 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
12655         if err := pcall(func() {
12656                 ((*(*(struct {
12657                         ID   SoundID
12658                         Step float32
12659                         Gain float32
12660                 }))(obj)).ID).deserialize(r)
12661         }); err != nil {
12662                 if err == io.EOF {
12663                         chk(io.EOF)
12664                 }
12665                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12666         }
12667         {
12668                 p := &(*(*(struct {
12669                         ID   SoundID
12670                         Step float32
12671                         Gain float32
12672                 }))(obj)).Step
12673                 *p = math.Float32frombits(read32(r))
12674         }
12675         {
12676                 p := &(*(*(struct {
12677                         ID   SoundID
12678                         Step float32
12679                         Gain float32
12680                 }))(obj)).Gain
12681                 *p = math.Float32frombits(read32(r))
12682         }
12683 }
12684
12685 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
12686         if err := pcall(func() {
12687                 ((*(*(struct {
12688                         Type    PlayerListUpdateType
12689                         Players []string
12690                 }))(obj)).Type).serialize(w)
12691         }); err != nil {
12692                 if err == io.EOF {
12693                         chk(io.EOF)
12694                 }
12695                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12696         }
12697         if len(((*(*(struct {
12698                 Type    PlayerListUpdateType
12699                 Players []string
12700         }))(obj)).Players)) > math.MaxUint16 {
12701                 chk(ErrTooLong)
12702         }
12703         {
12704                 x := uint16(len(((*(*(struct {
12705                         Type    PlayerListUpdateType
12706                         Players []string
12707                 }))(obj)).Players)))
12708                 write16(w, uint16(x))
12709         }
12710         for local208 := range (*(*(struct {
12711                 Type    PlayerListUpdateType
12712                 Players []string
12713         }))(obj)).Players {
12714                 if len(([]byte(((*(*(struct {
12715                         Type    PlayerListUpdateType
12716                         Players []string
12717                 }))(obj)).Players)[local208]))) > math.MaxUint16 {
12718                         chk(ErrTooLong)
12719                 }
12720                 {
12721                         x := uint16(len(([]byte(((*(*(struct {
12722                                 Type    PlayerListUpdateType
12723                                 Players []string
12724                         }))(obj)).Players)[local208]))))
12725                         write16(w, uint16(x))
12726                 }
12727                 {
12728                         _, err := w.Write(([]byte(((*(*(struct {
12729                                 Type    PlayerListUpdateType
12730                                 Players []string
12731                         }))(obj)).Players)[local208]))[:])
12732                         chk(err)
12733                 }
12734         }
12735 }
12736
12737 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
12738         if err := pcall(func() {
12739                 ((*(*(struct {
12740                         Type    PlayerListUpdateType
12741                         Players []string
12742                 }))(obj)).Type).deserialize(r)
12743         }); err != nil {
12744                 if err == io.EOF {
12745                         chk(io.EOF)
12746                 }
12747                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12748         }
12749         var local209 uint16
12750         {
12751                 p := &local209
12752                 *p = read16(r)
12753         }
12754         ((*(*(struct {
12755                 Type    PlayerListUpdateType
12756                 Players []string
12757         }))(obj)).Players) = make([]string, local209)
12758         for local210 := range (*(*(struct {
12759                 Type    PlayerListUpdateType
12760                 Players []string
12761         }))(obj)).Players {
12762                 var local211 []uint8
12763                 var local212 uint16
12764                 {
12765                         p := &local212
12766                         *p = read16(r)
12767                 }
12768                 (local211) = make([]uint8, local212)
12769                 {
12770                         _, err := io.ReadFull(r, (local211)[:])
12771                         chk(err)
12772                 }
12773                 (((*(*(struct {
12774                         Type    PlayerListUpdateType
12775                         Players []string
12776                 }))(obj)).Players)[local210]) = string(local211)
12777         }
12778 }
12779
12780 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
12781         if len(([]byte((*(*(struct {
12782                 Channel string
12783                 Sender  string
12784                 Msg     string
12785         }))(obj)).Channel))) > math.MaxUint16 {
12786                 chk(ErrTooLong)
12787         }
12788         {
12789                 x := uint16(len(([]byte((*(*(struct {
12790                         Channel string
12791                         Sender  string
12792                         Msg     string
12793                 }))(obj)).Channel))))
12794                 write16(w, uint16(x))
12795         }
12796         {
12797                 _, err := w.Write(([]byte((*(*(struct {
12798                         Channel string
12799                         Sender  string
12800                         Msg     string
12801                 }))(obj)).Channel))[:])
12802                 chk(err)
12803         }
12804         if len(([]byte((*(*(struct {
12805                 Channel string
12806                 Sender  string
12807                 Msg     string
12808         }))(obj)).Sender))) > math.MaxUint16 {
12809                 chk(ErrTooLong)
12810         }
12811         {
12812                 x := uint16(len(([]byte((*(*(struct {
12813                         Channel string
12814                         Sender  string
12815                         Msg     string
12816                 }))(obj)).Sender))))
12817                 write16(w, uint16(x))
12818         }
12819         {
12820                 _, err := w.Write(([]byte((*(*(struct {
12821                         Channel string
12822                         Sender  string
12823                         Msg     string
12824                 }))(obj)).Sender))[:])
12825                 chk(err)
12826         }
12827         if len(([]byte((*(*(struct {
12828                 Channel string
12829                 Sender  string
12830                 Msg     string
12831         }))(obj)).Msg))) > math.MaxUint16 {
12832                 chk(ErrTooLong)
12833         }
12834         {
12835                 x := uint16(len(([]byte((*(*(struct {
12836                         Channel string
12837                         Sender  string
12838                         Msg     string
12839                 }))(obj)).Msg))))
12840                 write16(w, uint16(x))
12841         }
12842         {
12843                 _, err := w.Write(([]byte((*(*(struct {
12844                         Channel string
12845                         Sender  string
12846                         Msg     string
12847                 }))(obj)).Msg))[:])
12848                 chk(err)
12849         }
12850 }
12851
12852 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
12853         var local213 []uint8
12854         var local214 uint16
12855         {
12856                 p := &local214
12857                 *p = read16(r)
12858         }
12859         (local213) = make([]uint8, local214)
12860         {
12861                 _, err := io.ReadFull(r, (local213)[:])
12862                 chk(err)
12863         }
12864         ((*(*(struct {
12865                 Channel string
12866                 Sender  string
12867                 Msg     string
12868         }))(obj)).Channel) = string(local213)
12869         var local215 []uint8
12870         var local216 uint16
12871         {
12872                 p := &local216
12873                 *p = read16(r)
12874         }
12875         (local215) = make([]uint8, local216)
12876         {
12877                 _, err := io.ReadFull(r, (local215)[:])
12878                 chk(err)
12879         }
12880         ((*(*(struct {
12881                 Channel string
12882                 Sender  string
12883                 Msg     string
12884         }))(obj)).Sender) = string(local215)
12885         var local217 []uint8
12886         var local218 uint16
12887         {
12888                 p := &local218
12889                 *p = read16(r)
12890         }
12891         (local217) = make([]uint8, local218)
12892         {
12893                 _, err := io.ReadFull(r, (local217)[:])
12894                 chk(err)
12895         }
12896         ((*(*(struct {
12897                 Channel string
12898                 Sender  string
12899                 Msg     string
12900         }))(obj)).Msg) = string(local217)
12901 }
12902
12903 func (obj *ToCltModChanSig) serialize(w io.Writer) {
12904         if err := pcall(func() {
12905                 ((*(*(struct {
12906                         Signal  ModChanSig
12907                         Channel string
12908                 }))(obj)).Signal).serialize(w)
12909         }); err != nil {
12910                 if err == io.EOF {
12911                         chk(io.EOF)
12912                 }
12913                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
12914         }
12915         if len(([]byte((*(*(struct {
12916                 Signal  ModChanSig
12917                 Channel string
12918         }))(obj)).Channel))) > math.MaxUint16 {
12919                 chk(ErrTooLong)
12920         }
12921         {
12922                 x := uint16(len(([]byte((*(*(struct {
12923                         Signal  ModChanSig
12924                         Channel string
12925                 }))(obj)).Channel))))
12926                 write16(w, uint16(x))
12927         }
12928         {
12929                 _, err := w.Write(([]byte((*(*(struct {
12930                         Signal  ModChanSig
12931                         Channel string
12932                 }))(obj)).Channel))[:])
12933                 chk(err)
12934         }
12935 }
12936
12937 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
12938         if err := pcall(func() {
12939                 ((*(*(struct {
12940                         Signal  ModChanSig
12941                         Channel string
12942                 }))(obj)).Signal).deserialize(r)
12943         }); err != nil {
12944                 if err == io.EOF {
12945                         chk(io.EOF)
12946                 }
12947                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
12948         }
12949         var local219 []uint8
12950         var local220 uint16
12951         {
12952                 p := &local220
12953                 *p = read16(r)
12954         }
12955         (local219) = make([]uint8, local220)
12956         {
12957                 _, err := io.ReadFull(r, (local219)[:])
12958                 chk(err)
12959         }
12960         ((*(*(struct {
12961                 Signal  ModChanSig
12962                 Channel string
12963         }))(obj)).Channel) = string(local219)
12964 }
12965
12966 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
12967         {
12968                 ow := w
12969                 w := new(bytes.Buffer)
12970                 {
12971                         x := (*(*(struct {
12972                                 //mt:lenhdr 32
12973                                 Changed map[[3]int16]*NodeMeta
12974                         }))(obj)).Changed
12975                         {
12976                                 w := zlib.NewWriter(w)
12977                                 if x == nil {
12978                                         write8(w, 0)
12979                                 } else {
12980                                         write8(w, 2)
12981                                         if len(x) > math.MaxUint16 {
12982                                                 chk(ErrTooLong)
12983                                         }
12984                                         write16(w, uint16(len(x)))
12985                                         keys := make([][3]int16, 0, len(x))
12986                                         for key := range x {
12987                                                 keys = append(keys, key)
12988                                         }
12989                                         sort.Slice(keys, func(i, j int) bool {
12990                                                 p, q := keys[i], keys[j]
12991                                                 for i := range p {
12992                                                         switch {
12993                                                         case p[i] < q[i]:
12994                                                                 return true
12995                                                         case p[i] > q[i]:
12996                                                                 return false
12997                                                         }
12998                                                 }
12999                                                 return false
13000                                         })
13001                                         for _, key := range keys {
13002                                                 for _, n := range key {
13003                                                         write16(w, uint16(n))
13004                                                 }
13005                                                 chk(serialize(w, x[key]))
13006                                         }
13007                                 }
13008                                 chk(w.Close())
13009                         }
13010                 }
13011                 {
13012                         buf := w
13013                         w := ow
13014                         if len((buf.Bytes())) > math.MaxUint32 {
13015                                 chk(ErrTooLong)
13016                         }
13017                         {
13018                                 x := uint32(len((buf.Bytes())))
13019                                 write32(w, uint32(x))
13020                         }
13021                         {
13022                                 _, err := w.Write((buf.Bytes())[:])
13023                                 chk(err)
13024                         }
13025                 }
13026         }
13027 }
13028
13029 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
13030         {
13031                 var n uint32
13032                 {
13033                         p := &n
13034                         *p = read32(r)
13035                 }
13036                 r := &io.LimitedReader{R: r, N: int64(n)}
13037                 {
13038                         p := &(*(*(struct {
13039                                 //mt:lenhdr 32
13040                                 Changed map[[3]int16]*NodeMeta
13041                         }))(obj)).Changed
13042                         {
13043                                 r, err := zlib.NewReader(byteReader{r})
13044                                 chk(err)
13045                                 switch ver := read8(r); ver {
13046                                 case 0:
13047                                         *p = nil
13048                                 case 2:
13049                                         n := read16(r)
13050                                         *p = make(map[[3]int16]*NodeMeta, n)
13051                                         for ; n > 0; n-- {
13052                                                 var pos [3]int16
13053                                                 for i := range pos {
13054                                                         pos[i] = int16(read16(r))
13055                                                 }
13056                                                 nm := new(NodeMeta)
13057                                                 chk(deserialize(r, nm))
13058                                                 (*p)[pos] = nm
13059                                         }
13060                                 default:
13061                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
13062                                 }
13063                                 chk(r.Close())
13064                         }
13065                 }
13066                 if r.N > 0 {
13067                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
13068                 }
13069         }
13070 }
13071
13072 func (obj *ToCltSunParams) serialize(w io.Writer) {
13073         {
13074                 x := (*(*(struct {
13075                         Visible bool
13076                         Texture
13077                         ToneMap Texture
13078                         Rise    Texture
13079                         Rising  bool
13080                         Size    float32
13081                 }))(obj)).Visible
13082                 if x {
13083                         write8(w, 1)
13084                 } else {
13085                         write8(w, 0)
13086                 }
13087         }
13088         if err := pcall(func() {
13089                 ((*(*(struct {
13090                         Visible bool
13091                         Texture
13092                         ToneMap Texture
13093                         Rise    Texture
13094                         Rising  bool
13095                         Size    float32
13096                 }))(obj)).Texture).serialize(w)
13097         }); err != nil {
13098                 if err == io.EOF {
13099                         chk(io.EOF)
13100                 }
13101                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13102         }
13103         if err := pcall(func() {
13104                 ((*(*(struct {
13105                         Visible bool
13106                         Texture
13107                         ToneMap Texture
13108                         Rise    Texture
13109                         Rising  bool
13110                         Size    float32
13111                 }))(obj)).ToneMap).serialize(w)
13112         }); err != nil {
13113                 if err == io.EOF {
13114                         chk(io.EOF)
13115                 }
13116                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13117         }
13118         if err := pcall(func() {
13119                 ((*(*(struct {
13120                         Visible bool
13121                         Texture
13122                         ToneMap Texture
13123                         Rise    Texture
13124                         Rising  bool
13125                         Size    float32
13126                 }))(obj)).Rise).serialize(w)
13127         }); err != nil {
13128                 if err == io.EOF {
13129                         chk(io.EOF)
13130                 }
13131                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13132         }
13133         {
13134                 x := (*(*(struct {
13135                         Visible bool
13136                         Texture
13137                         ToneMap Texture
13138                         Rise    Texture
13139                         Rising  bool
13140                         Size    float32
13141                 }))(obj)).Rising
13142                 if x {
13143                         write8(w, 1)
13144                 } else {
13145                         write8(w, 0)
13146                 }
13147         }
13148         {
13149                 x := (*(*(struct {
13150                         Visible bool
13151                         Texture
13152                         ToneMap Texture
13153                         Rise    Texture
13154                         Rising  bool
13155                         Size    float32
13156                 }))(obj)).Size
13157                 write32(w, math.Float32bits(x))
13158         }
13159 }
13160
13161 func (obj *ToCltSunParams) deserialize(r io.Reader) {
13162         {
13163                 p := &(*(*(struct {
13164                         Visible bool
13165                         Texture
13166                         ToneMap Texture
13167                         Rise    Texture
13168                         Rising  bool
13169                         Size    float32
13170                 }))(obj)).Visible
13171                 switch n := read8(r); n {
13172                 case 0:
13173                         *p = false
13174                 case 1:
13175                         *p = true
13176                 default:
13177                         chk(fmt.Errorf("invalid bool: %d", n))
13178                 }
13179         }
13180         if err := pcall(func() {
13181                 ((*(*(struct {
13182                         Visible bool
13183                         Texture
13184                         ToneMap Texture
13185                         Rise    Texture
13186                         Rising  bool
13187                         Size    float32
13188                 }))(obj)).Texture).deserialize(r)
13189         }); err != nil {
13190                 if err == io.EOF {
13191                         chk(io.EOF)
13192                 }
13193                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13194         }
13195         if err := pcall(func() {
13196                 ((*(*(struct {
13197                         Visible bool
13198                         Texture
13199                         ToneMap Texture
13200                         Rise    Texture
13201                         Rising  bool
13202                         Size    float32
13203                 }))(obj)).ToneMap).deserialize(r)
13204         }); err != nil {
13205                 if err == io.EOF {
13206                         chk(io.EOF)
13207                 }
13208                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13209         }
13210         if err := pcall(func() {
13211                 ((*(*(struct {
13212                         Visible bool
13213                         Texture
13214                         ToneMap Texture
13215                         Rise    Texture
13216                         Rising  bool
13217                         Size    float32
13218                 }))(obj)).Rise).deserialize(r)
13219         }); err != nil {
13220                 if err == io.EOF {
13221                         chk(io.EOF)
13222                 }
13223                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13224         }
13225         {
13226                 p := &(*(*(struct {
13227                         Visible bool
13228                         Texture
13229                         ToneMap Texture
13230                         Rise    Texture
13231                         Rising  bool
13232                         Size    float32
13233                 }))(obj)).Rising
13234                 switch n := read8(r); n {
13235                 case 0:
13236                         *p = false
13237                 case 1:
13238                         *p = true
13239                 default:
13240                         chk(fmt.Errorf("invalid bool: %d", n))
13241                 }
13242         }
13243         {
13244                 p := &(*(*(struct {
13245                         Visible bool
13246                         Texture
13247                         ToneMap Texture
13248                         Rise    Texture
13249                         Rising  bool
13250                         Size    float32
13251                 }))(obj)).Size
13252                 *p = math.Float32frombits(read32(r))
13253         }
13254 }
13255
13256 func (obj *ToCltMoonParams) serialize(w io.Writer) {
13257         {
13258                 x := (*(*(struct {
13259                         Visible bool
13260                         Texture
13261                         ToneMap Texture
13262                         Size    float32
13263                 }))(obj)).Visible
13264                 if x {
13265                         write8(w, 1)
13266                 } else {
13267                         write8(w, 0)
13268                 }
13269         }
13270         if err := pcall(func() {
13271                 ((*(*(struct {
13272                         Visible bool
13273                         Texture
13274                         ToneMap Texture
13275                         Size    float32
13276                 }))(obj)).Texture).serialize(w)
13277         }); err != nil {
13278                 if err == io.EOF {
13279                         chk(io.EOF)
13280                 }
13281                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13282         }
13283         if err := pcall(func() {
13284                 ((*(*(struct {
13285                         Visible bool
13286                         Texture
13287                         ToneMap Texture
13288                         Size    float32
13289                 }))(obj)).ToneMap).serialize(w)
13290         }); err != nil {
13291                 if err == io.EOF {
13292                         chk(io.EOF)
13293                 }
13294                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13295         }
13296         {
13297                 x := (*(*(struct {
13298                         Visible bool
13299                         Texture
13300                         ToneMap Texture
13301                         Size    float32
13302                 }))(obj)).Size
13303                 write32(w, math.Float32bits(x))
13304         }
13305 }
13306
13307 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
13308         {
13309                 p := &(*(*(struct {
13310                         Visible bool
13311                         Texture
13312                         ToneMap Texture
13313                         Size    float32
13314                 }))(obj)).Visible
13315                 switch n := read8(r); n {
13316                 case 0:
13317                         *p = false
13318                 case 1:
13319                         *p = true
13320                 default:
13321                         chk(fmt.Errorf("invalid bool: %d", n))
13322                 }
13323         }
13324         if err := pcall(func() {
13325                 ((*(*(struct {
13326                         Visible bool
13327                         Texture
13328                         ToneMap Texture
13329                         Size    float32
13330                 }))(obj)).Texture).deserialize(r)
13331         }); err != nil {
13332                 if err == io.EOF {
13333                         chk(io.EOF)
13334                 }
13335                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13336         }
13337         if err := pcall(func() {
13338                 ((*(*(struct {
13339                         Visible bool
13340                         Texture
13341                         ToneMap Texture
13342                         Size    float32
13343                 }))(obj)).ToneMap).deserialize(r)
13344         }); err != nil {
13345                 if err == io.EOF {
13346                         chk(io.EOF)
13347                 }
13348                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13349         }
13350         {
13351                 p := &(*(*(struct {
13352                         Visible bool
13353                         Texture
13354                         ToneMap Texture
13355                         Size    float32
13356                 }))(obj)).Size
13357                 *p = math.Float32frombits(read32(r))
13358         }
13359 }
13360
13361 func (obj *ToCltStarParams) serialize(w io.Writer) {
13362         {
13363                 x := (*(*(struct {
13364                         Visible bool
13365                         Count   uint32
13366                         Color   color.NRGBA
13367                         Size    float32
13368                 }))(obj)).Visible
13369                 if x {
13370                         write8(w, 1)
13371                 } else {
13372                         write8(w, 0)
13373                 }
13374         }
13375         {
13376                 x := (*(*(struct {
13377                         Visible bool
13378                         Count   uint32
13379                         Color   color.NRGBA
13380                         Size    float32
13381                 }))(obj)).Count
13382                 write32(w, uint32(x))
13383         }
13384         {
13385                 x := (*(*(struct {
13386                         Visible bool
13387                         Count   uint32
13388                         Color   color.NRGBA
13389                         Size    float32
13390                 }))(obj)).Color
13391                 w.Write([]byte{x.A, x.R, x.G, x.B})
13392         }
13393         {
13394                 x := (*(*(struct {
13395                         Visible bool
13396                         Count   uint32
13397                         Color   color.NRGBA
13398                         Size    float32
13399                 }))(obj)).Size
13400                 write32(w, math.Float32bits(x))
13401         }
13402 }
13403
13404 func (obj *ToCltStarParams) deserialize(r io.Reader) {
13405         {
13406                 p := &(*(*(struct {
13407                         Visible bool
13408                         Count   uint32
13409                         Color   color.NRGBA
13410                         Size    float32
13411                 }))(obj)).Visible
13412                 switch n := read8(r); n {
13413                 case 0:
13414                         *p = false
13415                 case 1:
13416                         *p = true
13417                 default:
13418                         chk(fmt.Errorf("invalid bool: %d", n))
13419                 }
13420         }
13421         {
13422                 p := &(*(*(struct {
13423                         Visible bool
13424                         Count   uint32
13425                         Color   color.NRGBA
13426                         Size    float32
13427                 }))(obj)).Count
13428                 *p = read32(r)
13429         }
13430         {
13431                 p := &(*(*(struct {
13432                         Visible bool
13433                         Count   uint32
13434                         Color   color.NRGBA
13435                         Size    float32
13436                 }))(obj)).Color
13437                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13438         }
13439         {
13440                 p := &(*(*(struct {
13441                         Visible bool
13442                         Count   uint32
13443                         Color   color.NRGBA
13444                         Size    float32
13445                 }))(obj)).Size
13446                 *p = math.Float32frombits(read32(r))
13447         }
13448 }
13449
13450 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
13451         if len(((*(*(struct {
13452                 Salt, B []byte
13453         }))(obj)).Salt)) > math.MaxUint16 {
13454                 chk(ErrTooLong)
13455         }
13456         {
13457                 x := uint16(len(((*(*(struct {
13458                         Salt, B []byte
13459                 }))(obj)).Salt)))
13460                 write16(w, uint16(x))
13461         }
13462         {
13463                 _, err := w.Write(((*(*(struct {
13464                         Salt, B []byte
13465                 }))(obj)).Salt)[:])
13466                 chk(err)
13467         }
13468         if len(((*(*(struct {
13469                 Salt, B []byte
13470         }))(obj)).B)) > math.MaxUint16 {
13471                 chk(ErrTooLong)
13472         }
13473         {
13474                 x := uint16(len(((*(*(struct {
13475                         Salt, B []byte
13476                 }))(obj)).B)))
13477                 write16(w, uint16(x))
13478         }
13479         {
13480                 _, err := w.Write(((*(*(struct {
13481                         Salt, B []byte
13482                 }))(obj)).B)[:])
13483                 chk(err)
13484         }
13485 }
13486
13487 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
13488         var local221 uint16
13489         {
13490                 p := &local221
13491                 *p = read16(r)
13492         }
13493         ((*(*(struct {
13494                 Salt, B []byte
13495         }))(obj)).Salt) = make([]byte, local221)
13496         {
13497                 _, err := io.ReadFull(r, ((*(*(struct {
13498                         Salt, B []byte
13499                 }))(obj)).Salt)[:])
13500                 chk(err)
13501         }
13502         var local222 uint16
13503         {
13504                 p := &local222
13505                 *p = read16(r)
13506         }
13507         ((*(*(struct {
13508                 Salt, B []byte
13509         }))(obj)).B) = make([]byte, local222)
13510         {
13511                 _, err := io.ReadFull(r, ((*(*(struct {
13512                         Salt, B []byte
13513                 }))(obj)).B)[:])
13514                 chk(err)
13515         }
13516 }
13517
13518 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
13519         if len(([]byte((*(*(struct {
13520                 Prepend string
13521         }))(obj)).Prepend))) > math.MaxUint16 {
13522                 chk(ErrTooLong)
13523         }
13524         {
13525                 x := uint16(len(([]byte((*(*(struct {
13526                         Prepend string
13527                 }))(obj)).Prepend))))
13528                 write16(w, uint16(x))
13529         }
13530         {
13531                 _, err := w.Write(([]byte((*(*(struct {
13532                         Prepend string
13533                 }))(obj)).Prepend))[:])
13534                 chk(err)
13535         }
13536 }
13537
13538 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
13539         var local223 []uint8
13540         var local224 uint16
13541         {
13542                 p := &local224
13543                 *p = read16(r)
13544         }
13545         (local223) = make([]uint8, local224)
13546         {
13547                 _, err := io.ReadFull(r, (local223)[:])
13548                 chk(err)
13549         }
13550         ((*(*(struct {
13551                 Prepend string
13552         }))(obj)).Prepend) = string(local223)
13553 }
13554
13555 func (obj *AOCmdProps) serialize(w io.Writer) {
13556         if err := pcall(func() {
13557                 ((*(*(struct {
13558                         Props AOProps
13559                 }))(obj)).Props).serialize(w)
13560         }); err != nil {
13561                 if err == io.EOF {
13562                         chk(io.EOF)
13563                 }
13564                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13565         }
13566 }
13567
13568 func (obj *AOCmdProps) deserialize(r io.Reader) {
13569         if err := pcall(func() {
13570                 ((*(*(struct {
13571                         Props AOProps
13572                 }))(obj)).Props).deserialize(r)
13573         }); err != nil {
13574                 if err == io.EOF {
13575                         chk(io.EOF)
13576                 }
13577                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13578         }
13579 }
13580
13581 func (obj *AOCmdPos) serialize(w io.Writer) {
13582         if err := pcall(func() {
13583                 ((*(*(struct {
13584                         Pos AOPos
13585                 }))(obj)).Pos).serialize(w)
13586         }); err != nil {
13587                 if err == io.EOF {
13588                         chk(io.EOF)
13589                 }
13590                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13591         }
13592 }
13593
13594 func (obj *AOCmdPos) deserialize(r io.Reader) {
13595         if err := pcall(func() {
13596                 ((*(*(struct {
13597                         Pos AOPos
13598                 }))(obj)).Pos).deserialize(r)
13599         }); err != nil {
13600                 if err == io.EOF {
13601                         chk(io.EOF)
13602                 }
13603                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13604         }
13605 }
13606
13607 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
13608         if err := pcall(func() {
13609                 ((*(*(struct {
13610                         Mod Texture // suffix
13611                 }))(obj)).Mod).serialize(w)
13612         }); err != nil {
13613                 if err == io.EOF {
13614                         chk(io.EOF)
13615                 }
13616                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13617         }
13618 }
13619
13620 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
13621         if err := pcall(func() {
13622                 ((*(*(struct {
13623                         Mod Texture // suffix
13624                 }))(obj)).Mod).deserialize(r)
13625         }); err != nil {
13626                 if err == io.EOF {
13627                         chk(io.EOF)
13628                 }
13629                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13630         }
13631 }
13632
13633 func (obj *AOCmdSprite) serialize(w io.Writer) {
13634         if err := pcall(func() {
13635                 ((*(*(struct {
13636                         Sprite AOSprite
13637                 }))(obj)).Sprite).serialize(w)
13638         }); err != nil {
13639                 if err == io.EOF {
13640                         chk(io.EOF)
13641                 }
13642                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13643         }
13644 }
13645
13646 func (obj *AOCmdSprite) deserialize(r io.Reader) {
13647         if err := pcall(func() {
13648                 ((*(*(struct {
13649                         Sprite AOSprite
13650                 }))(obj)).Sprite).deserialize(r)
13651         }); err != nil {
13652                 if err == io.EOF {
13653                         chk(io.EOF)
13654                 }
13655                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13656         }
13657 }
13658
13659 func (obj *AOCmdHP) serialize(w io.Writer) {
13660         {
13661                 x := (*(*(struct {
13662                         HP uint16
13663                 }))(obj)).HP
13664                 write16(w, uint16(x))
13665         }
13666 }
13667
13668 func (obj *AOCmdHP) deserialize(r io.Reader) {
13669         {
13670                 p := &(*(*(struct {
13671                         HP uint16
13672                 }))(obj)).HP
13673                 *p = read16(r)
13674         }
13675 }
13676
13677 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
13678         if len(((*(*(struct {
13679                 Armor []Group
13680         }))(obj)).Armor)) > math.MaxUint16 {
13681                 chk(ErrTooLong)
13682         }
13683         {
13684                 x := uint16(len(((*(*(struct {
13685                         Armor []Group
13686                 }))(obj)).Armor)))
13687                 write16(w, uint16(x))
13688         }
13689         for local225 := range (*(*(struct {
13690                 Armor []Group
13691         }))(obj)).Armor {
13692                 if err := pcall(func() {
13693                         (((*(*(struct {
13694                                 Armor []Group
13695                         }))(obj)).Armor)[local225]).serialize(w)
13696                 }); err != nil {
13697                         if err == io.EOF {
13698                                 chk(io.EOF)
13699                         }
13700                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
13701                 }
13702         }
13703 }
13704
13705 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
13706         var local226 uint16
13707         {
13708                 p := &local226
13709                 *p = read16(r)
13710         }
13711         ((*(*(struct {
13712                 Armor []Group
13713         }))(obj)).Armor) = make([]Group, local226)
13714         for local227 := range (*(*(struct {
13715                 Armor []Group
13716         }))(obj)).Armor {
13717                 if err := pcall(func() {
13718                         (((*(*(struct {
13719                                 Armor []Group
13720                         }))(obj)).Armor)[local227]).deserialize(r)
13721                 }); err != nil {
13722                         if err == io.EOF {
13723                                 chk(io.EOF)
13724                         }
13725                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
13726                 }
13727         }
13728 }
13729
13730 func (obj *AOCmdAnim) serialize(w io.Writer) {
13731         if err := pcall(func() {
13732                 ((*(*(struct {
13733                         Anim AOAnim
13734                 }))(obj)).Anim).serialize(w)
13735         }); err != nil {
13736                 if err == io.EOF {
13737                         chk(io.EOF)
13738                 }
13739                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13740         }
13741 }
13742
13743 func (obj *AOCmdAnim) deserialize(r io.Reader) {
13744         if err := pcall(func() {
13745                 ((*(*(struct {
13746                         Anim AOAnim
13747                 }))(obj)).Anim).deserialize(r)
13748         }); err != nil {
13749                 if err == io.EOF {
13750                         chk(io.EOF)
13751                 }
13752                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13753         }
13754 }
13755
13756 func (obj *AOCmdBonePos) serialize(w io.Writer) {
13757         if len(([]byte((*(*(struct {
13758                 Bone string
13759                 Pos  AOBonePos
13760         }))(obj)).Bone))) > math.MaxUint16 {
13761                 chk(ErrTooLong)
13762         }
13763         {
13764                 x := uint16(len(([]byte((*(*(struct {
13765                         Bone string
13766                         Pos  AOBonePos
13767                 }))(obj)).Bone))))
13768                 write16(w, uint16(x))
13769         }
13770         {
13771                 _, err := w.Write(([]byte((*(*(struct {
13772                         Bone string
13773                         Pos  AOBonePos
13774                 }))(obj)).Bone))[:])
13775                 chk(err)
13776         }
13777         if err := pcall(func() {
13778                 ((*(*(struct {
13779                         Bone string
13780                         Pos  AOBonePos
13781                 }))(obj)).Pos).serialize(w)
13782         }); err != nil {
13783                 if err == io.EOF {
13784                         chk(io.EOF)
13785                 }
13786                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13787         }
13788 }
13789
13790 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
13791         var local228 []uint8
13792         var local229 uint16
13793         {
13794                 p := &local229
13795                 *p = read16(r)
13796         }
13797         (local228) = make([]uint8, local229)
13798         {
13799                 _, err := io.ReadFull(r, (local228)[:])
13800                 chk(err)
13801         }
13802         ((*(*(struct {
13803                 Bone string
13804                 Pos  AOBonePos
13805         }))(obj)).Bone) = string(local228)
13806         if err := pcall(func() {
13807                 ((*(*(struct {
13808                         Bone string
13809                         Pos  AOBonePos
13810                 }))(obj)).Pos).deserialize(r)
13811         }); err != nil {
13812                 if err == io.EOF {
13813                         chk(io.EOF)
13814                 }
13815                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13816         }
13817 }
13818
13819 func (obj *AOCmdAttach) serialize(w io.Writer) {
13820         if err := pcall(func() {
13821                 ((*(*(struct {
13822                         Attach AOAttach
13823                 }))(obj)).Attach).serialize(w)
13824         }); err != nil {
13825                 if err == io.EOF {
13826                         chk(io.EOF)
13827                 }
13828                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13829         }
13830 }
13831
13832 func (obj *AOCmdAttach) deserialize(r io.Reader) {
13833         if err := pcall(func() {
13834                 ((*(*(struct {
13835                         Attach AOAttach
13836                 }))(obj)).Attach).deserialize(r)
13837         }); err != nil {
13838                 if err == io.EOF {
13839                         chk(io.EOF)
13840                 }
13841                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13842         }
13843 }
13844
13845 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
13846         if err := pcall(func() {
13847                 ((*(*(struct {
13848                         Phys AOPhysOverride
13849                 }))(obj)).Phys).serialize(w)
13850         }); err != nil {
13851                 if err == io.EOF {
13852                         chk(io.EOF)
13853                 }
13854                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13855         }
13856 }
13857
13858 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
13859         if err := pcall(func() {
13860                 ((*(*(struct {
13861                         Phys AOPhysOverride
13862                 }))(obj)).Phys).deserialize(r)
13863         }); err != nil {
13864                 if err == io.EOF {
13865                         chk(io.EOF)
13866                 }
13867                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13868         }
13869 }
13870
13871 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
13872         if err := pcall(func() {
13873                 ((*(*(struct {
13874                         ID AOID
13875                 }))(obj)).ID).serialize(w)
13876         }); err != nil {
13877                 if err == io.EOF {
13878                         chk(io.EOF)
13879                 }
13880                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13881         }
13882         {
13883                 local230 := genericCAO
13884                 if err := pcall(func() {
13885                         (local230).serialize(w)
13886                 }); err != nil {
13887                         if err == io.EOF {
13888                                 chk(io.EOF)
13889                         }
13890                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13891                 }
13892         }
13893 }
13894
13895 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
13896         if err := pcall(func() {
13897                 ((*(*(struct {
13898                         ID AOID
13899                 }))(obj)).ID).deserialize(r)
13900         }); err != nil {
13901                 if err == io.EOF {
13902                         chk(io.EOF)
13903                 }
13904                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13905         }
13906         {
13907                 var local231 aoType
13908                 local232 := genericCAO
13909                 if err := pcall(func() {
13910                         (local231).deserialize(r)
13911                 }); err != nil {
13912                         if err == io.EOF {
13913                                 chk(io.EOF)
13914                         }
13915                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13916                 }
13917                 if local231 != local232 {
13918                         chk(fmt.Errorf("const %v: %v", "genericCAO", local231))
13919                 }
13920         }
13921 }
13922
13923 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
13924         {
13925                 x := (*(*(struct {
13926                         Speed float32
13927                 }))(obj)).Speed
13928                 write32(w, math.Float32bits(x))
13929         }
13930 }
13931
13932 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
13933         {
13934                 p := &(*(*(struct {
13935                         Speed float32
13936                 }))(obj)).Speed
13937                 *p = math.Float32frombits(read32(r))
13938         }
13939 }
13940
13941 func (obj *NodeMeta) serialize(w io.Writer) {
13942         if len(((*(*(struct {
13943                 //mt:len32
13944                 Fields []NodeMetaField
13945
13946                 Inv Inv
13947         }))(obj)).Fields)) > math.MaxUint32 {
13948                 chk(ErrTooLong)
13949         }
13950         {
13951                 x := uint32(len(((*(*(struct {
13952                         //mt:len32
13953                         Fields []NodeMetaField
13954
13955                         Inv Inv
13956                 }))(obj)).Fields)))
13957                 write32(w, uint32(x))
13958         }
13959         for local233 := range (*(*(struct {
13960                 //mt:len32
13961                 Fields []NodeMetaField
13962
13963                 Inv Inv
13964         }))(obj)).Fields {
13965                 if err := pcall(func() {
13966                         (((*(*(struct {
13967                                 //mt:len32
13968                                 Fields []NodeMetaField
13969
13970                                 Inv Inv
13971                         }))(obj)).Fields)[local233]).serialize(w)
13972                 }); err != nil {
13973                         if err == io.EOF {
13974                                 chk(io.EOF)
13975                         }
13976                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
13977                 }
13978         }
13979         chk(((*(*(struct {
13980                 //mt:len32
13981                 Fields []NodeMetaField
13982
13983                 Inv Inv
13984         }))(obj)).Inv).Serialize(w))
13985 }
13986
13987 func (obj *NodeMeta) deserialize(r io.Reader) {
13988         var local234 uint32
13989         {
13990                 p := &local234
13991                 *p = read32(r)
13992         }
13993         ((*(*(struct {
13994                 //mt:len32
13995                 Fields []NodeMetaField
13996
13997                 Inv Inv
13998         }))(obj)).Fields) = make([]NodeMetaField, local234)
13999         for local235 := range (*(*(struct {
14000                 //mt:len32
14001                 Fields []NodeMetaField
14002
14003                 Inv Inv
14004         }))(obj)).Fields {
14005                 if err := pcall(func() {
14006                         (((*(*(struct {
14007                                 //mt:len32
14008                                 Fields []NodeMetaField
14009
14010                                 Inv Inv
14011                         }))(obj)).Fields)[local235]).deserialize(r)
14012                 }); err != nil {
14013                         if err == io.EOF {
14014                                 chk(io.EOF)
14015                         }
14016                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
14017                 }
14018         }
14019         chk(((*(*(struct {
14020                 //mt:len32
14021                 Fields []NodeMetaField
14022
14023                 Inv Inv
14024         }))(obj)).Inv).Deserialize(r))
14025 }
14026
14027 func (obj *MinimapMode) serialize(w io.Writer) {
14028         if err := pcall(func() {
14029                 ((*(*(struct {
14030                         Type  MinimapType
14031                         Label string
14032                         Size  uint16
14033                         Texture
14034                         Scale uint16
14035                 }))(obj)).Type).serialize(w)
14036         }); err != nil {
14037                 if err == io.EOF {
14038                         chk(io.EOF)
14039                 }
14040                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14041         }
14042         if len(([]byte((*(*(struct {
14043                 Type  MinimapType
14044                 Label string
14045                 Size  uint16
14046                 Texture
14047                 Scale uint16
14048         }))(obj)).Label))) > math.MaxUint16 {
14049                 chk(ErrTooLong)
14050         }
14051         {
14052                 x := uint16(len(([]byte((*(*(struct {
14053                         Type  MinimapType
14054                         Label string
14055                         Size  uint16
14056                         Texture
14057                         Scale uint16
14058                 }))(obj)).Label))))
14059                 write16(w, uint16(x))
14060         }
14061         {
14062                 _, err := w.Write(([]byte((*(*(struct {
14063                         Type  MinimapType
14064                         Label string
14065                         Size  uint16
14066                         Texture
14067                         Scale uint16
14068                 }))(obj)).Label))[:])
14069                 chk(err)
14070         }
14071         {
14072                 x := (*(*(struct {
14073                         Type  MinimapType
14074                         Label string
14075                         Size  uint16
14076                         Texture
14077                         Scale uint16
14078                 }))(obj)).Size
14079                 write16(w, uint16(x))
14080         }
14081         if err := pcall(func() {
14082                 ((*(*(struct {
14083                         Type  MinimapType
14084                         Label string
14085                         Size  uint16
14086                         Texture
14087                         Scale uint16
14088                 }))(obj)).Texture).serialize(w)
14089         }); err != nil {
14090                 if err == io.EOF {
14091                         chk(io.EOF)
14092                 }
14093                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14094         }
14095         {
14096                 x := (*(*(struct {
14097                         Type  MinimapType
14098                         Label string
14099                         Size  uint16
14100                         Texture
14101                         Scale uint16
14102                 }))(obj)).Scale
14103                 write16(w, uint16(x))
14104         }
14105 }
14106
14107 func (obj *MinimapMode) deserialize(r io.Reader) {
14108         if err := pcall(func() {
14109                 ((*(*(struct {
14110                         Type  MinimapType
14111                         Label string
14112                         Size  uint16
14113                         Texture
14114                         Scale uint16
14115                 }))(obj)).Type).deserialize(r)
14116         }); err != nil {
14117                 if err == io.EOF {
14118                         chk(io.EOF)
14119                 }
14120                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14121         }
14122         var local236 []uint8
14123         var local237 uint16
14124         {
14125                 p := &local237
14126                 *p = read16(r)
14127         }
14128         (local236) = make([]uint8, local237)
14129         {
14130                 _, err := io.ReadFull(r, (local236)[:])
14131                 chk(err)
14132         }
14133         ((*(*(struct {
14134                 Type  MinimapType
14135                 Label string
14136                 Size  uint16
14137                 Texture
14138                 Scale uint16
14139         }))(obj)).Label) = string(local236)
14140         {
14141                 p := &(*(*(struct {
14142                         Type  MinimapType
14143                         Label string
14144                         Size  uint16
14145                         Texture
14146                         Scale uint16
14147                 }))(obj)).Size
14148                 *p = read16(r)
14149         }
14150         if err := pcall(func() {
14151                 ((*(*(struct {
14152                         Type  MinimapType
14153                         Label string
14154                         Size  uint16
14155                         Texture
14156                         Scale uint16
14157                 }))(obj)).Texture).deserialize(r)
14158         }); err != nil {
14159                 if err == io.EOF {
14160                         chk(io.EOF)
14161                 }
14162                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14163         }
14164         {
14165                 p := &(*(*(struct {
14166                         Type  MinimapType
14167                         Label string
14168                         Size  uint16
14169                         Texture
14170                         Scale uint16
14171                 }))(obj)).Scale
14172                 *p = read16(r)
14173         }
14174 }
14175
14176 func (obj *NodeDef) serialize(w io.Writer) {
14177         if err := pcall(func() {
14178                 ((*(*(struct {
14179                         Param0 Content
14180
14181                         Name   string
14182                         Groups []Group
14183
14184                         P1Type   Param1Type
14185                         P2Type   Param2Type
14186                         DrawType DrawType
14187
14188                         Mesh  string
14189                         Scale float32
14190                         //mt:const uint8(6)
14191                         Tiles        [6]TileDef
14192                         OverlayTiles [6]TileDef
14193                         //mt:const uint8(6)
14194                         SpecialTiles [6]TileDef
14195
14196                         Color   color.NRGBA
14197                         Palette Texture
14198
14199                         Waving       WaveType
14200                         ConnectSides uint8
14201                         ConnectTo    []Content
14202                         InsideTint   color.NRGBA
14203                         Level        uint8 // Must be < 128.
14204
14205                         Translucent bool // Sunlight is scattered and becomes normal light.
14206                         Transparent bool // Sunlight isn't scattered.
14207                         LightSrc    uint8
14208
14209                         GndContent   bool
14210                         Collides     bool
14211                         Pointable    bool
14212                         Diggable     bool
14213                         Climbable    bool
14214                         Replaceable  bool
14215                         OnRightClick bool
14216
14217                         DmgPerSec int32
14218
14219                         LiquidType   LiquidType
14220                         FlowingAlt   string
14221                         SrcAlt       string
14222                         Viscosity    uint8 // 0-7
14223                         LiqRenewable bool
14224                         FlowRange    uint8
14225                         DrownDmg     uint8
14226                         Floodable    bool
14227
14228                         DrawBox, ColBox, SelBox NodeBox
14229
14230                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14231
14232                         LegacyFaceDir bool
14233                         LegacyMounted bool
14234
14235                         DigPredict string
14236
14237                         MaxLvl uint8
14238
14239                         AlphaUse
14240                 }))(obj)).Param0).serialize(w)
14241         }); err != nil {
14242                 if err == io.EOF {
14243                         chk(io.EOF)
14244                 }
14245                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
14246         }
14247         {
14248                 ow := w
14249                 w := new(bytes.Buffer)
14250                 {
14251                         local238 := uint8(13)
14252                         {
14253                                 x := local238
14254                                 write8(w, uint8(x))
14255                         }
14256                 }
14257                 if len(([]byte((*(*(struct {
14258                         Param0 Content
14259
14260                         Name   string
14261                         Groups []Group
14262
14263                         P1Type   Param1Type
14264                         P2Type   Param2Type
14265                         DrawType DrawType
14266
14267                         Mesh  string
14268                         Scale float32
14269                         //mt:const uint8(6)
14270                         Tiles        [6]TileDef
14271                         OverlayTiles [6]TileDef
14272                         //mt:const uint8(6)
14273                         SpecialTiles [6]TileDef
14274
14275                         Color   color.NRGBA
14276                         Palette Texture
14277
14278                         Waving       WaveType
14279                         ConnectSides uint8
14280                         ConnectTo    []Content
14281                         InsideTint   color.NRGBA
14282                         Level        uint8 // Must be < 128.
14283
14284                         Translucent bool // Sunlight is scattered and becomes normal light.
14285                         Transparent bool // Sunlight isn't scattered.
14286                         LightSrc    uint8
14287
14288                         GndContent   bool
14289                         Collides     bool
14290                         Pointable    bool
14291                         Diggable     bool
14292                         Climbable    bool
14293                         Replaceable  bool
14294                         OnRightClick bool
14295
14296                         DmgPerSec int32
14297
14298                         LiquidType   LiquidType
14299                         FlowingAlt   string
14300                         SrcAlt       string
14301                         Viscosity    uint8 // 0-7
14302                         LiqRenewable bool
14303                         FlowRange    uint8
14304                         DrownDmg     uint8
14305                         Floodable    bool
14306
14307                         DrawBox, ColBox, SelBox NodeBox
14308
14309                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14310
14311                         LegacyFaceDir bool
14312                         LegacyMounted bool
14313
14314                         DigPredict string
14315
14316                         MaxLvl uint8
14317
14318                         AlphaUse
14319                 }))(obj)).Name))) > math.MaxUint16 {
14320                         chk(ErrTooLong)
14321                 }
14322                 {
14323                         x := uint16(len(([]byte((*(*(struct {
14324                                 Param0 Content
14325
14326                                 Name   string
14327                                 Groups []Group
14328
14329                                 P1Type   Param1Type
14330                                 P2Type   Param2Type
14331                                 DrawType DrawType
14332
14333                                 Mesh  string
14334                                 Scale float32
14335                                 //mt:const uint8(6)
14336                                 Tiles        [6]TileDef
14337                                 OverlayTiles [6]TileDef
14338                                 //mt:const uint8(6)
14339                                 SpecialTiles [6]TileDef
14340
14341                                 Color   color.NRGBA
14342                                 Palette Texture
14343
14344                                 Waving       WaveType
14345                                 ConnectSides uint8
14346                                 ConnectTo    []Content
14347                                 InsideTint   color.NRGBA
14348                                 Level        uint8 // Must be < 128.
14349
14350                                 Translucent bool // Sunlight is scattered and becomes normal light.
14351                                 Transparent bool // Sunlight isn't scattered.
14352                                 LightSrc    uint8
14353
14354                                 GndContent   bool
14355                                 Collides     bool
14356                                 Pointable    bool
14357                                 Diggable     bool
14358                                 Climbable    bool
14359                                 Replaceable  bool
14360                                 OnRightClick bool
14361
14362                                 DmgPerSec int32
14363
14364                                 LiquidType   LiquidType
14365                                 FlowingAlt   string
14366                                 SrcAlt       string
14367                                 Viscosity    uint8 // 0-7
14368                                 LiqRenewable bool
14369                                 FlowRange    uint8
14370                                 DrownDmg     uint8
14371                                 Floodable    bool
14372
14373                                 DrawBox, ColBox, SelBox NodeBox
14374
14375                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14376
14377                                 LegacyFaceDir bool
14378                                 LegacyMounted bool
14379
14380                                 DigPredict string
14381
14382                                 MaxLvl uint8
14383
14384                                 AlphaUse
14385                         }))(obj)).Name))))
14386                         write16(w, uint16(x))
14387                 }
14388                 {
14389                         _, err := w.Write(([]byte((*(*(struct {
14390                                 Param0 Content
14391
14392                                 Name   string
14393                                 Groups []Group
14394
14395                                 P1Type   Param1Type
14396                                 P2Type   Param2Type
14397                                 DrawType DrawType
14398
14399                                 Mesh  string
14400                                 Scale float32
14401                                 //mt:const uint8(6)
14402                                 Tiles        [6]TileDef
14403                                 OverlayTiles [6]TileDef
14404                                 //mt:const uint8(6)
14405                                 SpecialTiles [6]TileDef
14406
14407                                 Color   color.NRGBA
14408                                 Palette Texture
14409
14410                                 Waving       WaveType
14411                                 ConnectSides uint8
14412                                 ConnectTo    []Content
14413                                 InsideTint   color.NRGBA
14414                                 Level        uint8 // Must be < 128.
14415
14416                                 Translucent bool // Sunlight is scattered and becomes normal light.
14417                                 Transparent bool // Sunlight isn't scattered.
14418                                 LightSrc    uint8
14419
14420                                 GndContent   bool
14421                                 Collides     bool
14422                                 Pointable    bool
14423                                 Diggable     bool
14424                                 Climbable    bool
14425                                 Replaceable  bool
14426                                 OnRightClick bool
14427
14428                                 DmgPerSec int32
14429
14430                                 LiquidType   LiquidType
14431                                 FlowingAlt   string
14432                                 SrcAlt       string
14433                                 Viscosity    uint8 // 0-7
14434                                 LiqRenewable bool
14435                                 FlowRange    uint8
14436                                 DrownDmg     uint8
14437                                 Floodable    bool
14438
14439                                 DrawBox, ColBox, SelBox NodeBox
14440
14441                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14442
14443                                 LegacyFaceDir bool
14444                                 LegacyMounted bool
14445
14446                                 DigPredict string
14447
14448                                 MaxLvl uint8
14449
14450                                 AlphaUse
14451                         }))(obj)).Name))[:])
14452                         chk(err)
14453                 }
14454                 if len(((*(*(struct {
14455                         Param0 Content
14456
14457                         Name   string
14458                         Groups []Group
14459
14460                         P1Type   Param1Type
14461                         P2Type   Param2Type
14462                         DrawType DrawType
14463
14464                         Mesh  string
14465                         Scale float32
14466                         //mt:const uint8(6)
14467                         Tiles        [6]TileDef
14468                         OverlayTiles [6]TileDef
14469                         //mt:const uint8(6)
14470                         SpecialTiles [6]TileDef
14471
14472                         Color   color.NRGBA
14473                         Palette Texture
14474
14475                         Waving       WaveType
14476                         ConnectSides uint8
14477                         ConnectTo    []Content
14478                         InsideTint   color.NRGBA
14479                         Level        uint8 // Must be < 128.
14480
14481                         Translucent bool // Sunlight is scattered and becomes normal light.
14482                         Transparent bool // Sunlight isn't scattered.
14483                         LightSrc    uint8
14484
14485                         GndContent   bool
14486                         Collides     bool
14487                         Pointable    bool
14488                         Diggable     bool
14489                         Climbable    bool
14490                         Replaceable  bool
14491                         OnRightClick bool
14492
14493                         DmgPerSec int32
14494
14495                         LiquidType   LiquidType
14496                         FlowingAlt   string
14497                         SrcAlt       string
14498                         Viscosity    uint8 // 0-7
14499                         LiqRenewable bool
14500                         FlowRange    uint8
14501                         DrownDmg     uint8
14502                         Floodable    bool
14503
14504                         DrawBox, ColBox, SelBox NodeBox
14505
14506                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14507
14508                         LegacyFaceDir bool
14509                         LegacyMounted bool
14510
14511                         DigPredict string
14512
14513                         MaxLvl uint8
14514
14515                         AlphaUse
14516                 }))(obj)).Groups)) > math.MaxUint16 {
14517                         chk(ErrTooLong)
14518                 }
14519                 {
14520                         x := uint16(len(((*(*(struct {
14521                                 Param0 Content
14522
14523                                 Name   string
14524                                 Groups []Group
14525
14526                                 P1Type   Param1Type
14527                                 P2Type   Param2Type
14528                                 DrawType DrawType
14529
14530                                 Mesh  string
14531                                 Scale float32
14532                                 //mt:const uint8(6)
14533                                 Tiles        [6]TileDef
14534                                 OverlayTiles [6]TileDef
14535                                 //mt:const uint8(6)
14536                                 SpecialTiles [6]TileDef
14537
14538                                 Color   color.NRGBA
14539                                 Palette Texture
14540
14541                                 Waving       WaveType
14542                                 ConnectSides uint8
14543                                 ConnectTo    []Content
14544                                 InsideTint   color.NRGBA
14545                                 Level        uint8 // Must be < 128.
14546
14547                                 Translucent bool // Sunlight is scattered and becomes normal light.
14548                                 Transparent bool // Sunlight isn't scattered.
14549                                 LightSrc    uint8
14550
14551                                 GndContent   bool
14552                                 Collides     bool
14553                                 Pointable    bool
14554                                 Diggable     bool
14555                                 Climbable    bool
14556                                 Replaceable  bool
14557                                 OnRightClick bool
14558
14559                                 DmgPerSec int32
14560
14561                                 LiquidType   LiquidType
14562                                 FlowingAlt   string
14563                                 SrcAlt       string
14564                                 Viscosity    uint8 // 0-7
14565                                 LiqRenewable bool
14566                                 FlowRange    uint8
14567                                 DrownDmg     uint8
14568                                 Floodable    bool
14569
14570                                 DrawBox, ColBox, SelBox NodeBox
14571
14572                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14573
14574                                 LegacyFaceDir bool
14575                                 LegacyMounted bool
14576
14577                                 DigPredict string
14578
14579                                 MaxLvl uint8
14580
14581                                 AlphaUse
14582                         }))(obj)).Groups)))
14583                         write16(w, uint16(x))
14584                 }
14585                 for local239 := range (*(*(struct {
14586                         Param0 Content
14587
14588                         Name   string
14589                         Groups []Group
14590
14591                         P1Type   Param1Type
14592                         P2Type   Param2Type
14593                         DrawType DrawType
14594
14595                         Mesh  string
14596                         Scale float32
14597                         //mt:const uint8(6)
14598                         Tiles        [6]TileDef
14599                         OverlayTiles [6]TileDef
14600                         //mt:const uint8(6)
14601                         SpecialTiles [6]TileDef
14602
14603                         Color   color.NRGBA
14604                         Palette Texture
14605
14606                         Waving       WaveType
14607                         ConnectSides uint8
14608                         ConnectTo    []Content
14609                         InsideTint   color.NRGBA
14610                         Level        uint8 // Must be < 128.
14611
14612                         Translucent bool // Sunlight is scattered and becomes normal light.
14613                         Transparent bool // Sunlight isn't scattered.
14614                         LightSrc    uint8
14615
14616                         GndContent   bool
14617                         Collides     bool
14618                         Pointable    bool
14619                         Diggable     bool
14620                         Climbable    bool
14621                         Replaceable  bool
14622                         OnRightClick bool
14623
14624                         DmgPerSec int32
14625
14626                         LiquidType   LiquidType
14627                         FlowingAlt   string
14628                         SrcAlt       string
14629                         Viscosity    uint8 // 0-7
14630                         LiqRenewable bool
14631                         FlowRange    uint8
14632                         DrownDmg     uint8
14633                         Floodable    bool
14634
14635                         DrawBox, ColBox, SelBox NodeBox
14636
14637                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14638
14639                         LegacyFaceDir bool
14640                         LegacyMounted bool
14641
14642                         DigPredict string
14643
14644                         MaxLvl uint8
14645
14646                         AlphaUse
14647                 }))(obj)).Groups {
14648                         if err := pcall(func() {
14649                                 (((*(*(struct {
14650                                         Param0 Content
14651
14652                                         Name   string
14653                                         Groups []Group
14654
14655                                         P1Type   Param1Type
14656                                         P2Type   Param2Type
14657                                         DrawType DrawType
14658
14659                                         Mesh  string
14660                                         Scale float32
14661                                         //mt:const uint8(6)
14662                                         Tiles        [6]TileDef
14663                                         OverlayTiles [6]TileDef
14664                                         //mt:const uint8(6)
14665                                         SpecialTiles [6]TileDef
14666
14667                                         Color   color.NRGBA
14668                                         Palette Texture
14669
14670                                         Waving       WaveType
14671                                         ConnectSides uint8
14672                                         ConnectTo    []Content
14673                                         InsideTint   color.NRGBA
14674                                         Level        uint8 // Must be < 128.
14675
14676                                         Translucent bool // Sunlight is scattered and becomes normal light.
14677                                         Transparent bool // Sunlight isn't scattered.
14678                                         LightSrc    uint8
14679
14680                                         GndContent   bool
14681                                         Collides     bool
14682                                         Pointable    bool
14683                                         Diggable     bool
14684                                         Climbable    bool
14685                                         Replaceable  bool
14686                                         OnRightClick bool
14687
14688                                         DmgPerSec int32
14689
14690                                         LiquidType   LiquidType
14691                                         FlowingAlt   string
14692                                         SrcAlt       string
14693                                         Viscosity    uint8 // 0-7
14694                                         LiqRenewable bool
14695                                         FlowRange    uint8
14696                                         DrownDmg     uint8
14697                                         Floodable    bool
14698
14699                                         DrawBox, ColBox, SelBox NodeBox
14700
14701                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14702
14703                                         LegacyFaceDir bool
14704                                         LegacyMounted bool
14705
14706                                         DigPredict string
14707
14708                                         MaxLvl uint8
14709
14710                                         AlphaUse
14711                                 }))(obj)).Groups)[local239]).serialize(w)
14712                         }); err != nil {
14713                                 if err == io.EOF {
14714                                         chk(io.EOF)
14715                                 }
14716                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
14717                         }
14718                 }
14719                 if err := pcall(func() {
14720                         ((*(*(struct {
14721                                 Param0 Content
14722
14723                                 Name   string
14724                                 Groups []Group
14725
14726                                 P1Type   Param1Type
14727                                 P2Type   Param2Type
14728                                 DrawType DrawType
14729
14730                                 Mesh  string
14731                                 Scale float32
14732                                 //mt:const uint8(6)
14733                                 Tiles        [6]TileDef
14734                                 OverlayTiles [6]TileDef
14735                                 //mt:const uint8(6)
14736                                 SpecialTiles [6]TileDef
14737
14738                                 Color   color.NRGBA
14739                                 Palette Texture
14740
14741                                 Waving       WaveType
14742                                 ConnectSides uint8
14743                                 ConnectTo    []Content
14744                                 InsideTint   color.NRGBA
14745                                 Level        uint8 // Must be < 128.
14746
14747                                 Translucent bool // Sunlight is scattered and becomes normal light.
14748                                 Transparent bool // Sunlight isn't scattered.
14749                                 LightSrc    uint8
14750
14751                                 GndContent   bool
14752                                 Collides     bool
14753                                 Pointable    bool
14754                                 Diggable     bool
14755                                 Climbable    bool
14756                                 Replaceable  bool
14757                                 OnRightClick bool
14758
14759                                 DmgPerSec int32
14760
14761                                 LiquidType   LiquidType
14762                                 FlowingAlt   string
14763                                 SrcAlt       string
14764                                 Viscosity    uint8 // 0-7
14765                                 LiqRenewable bool
14766                                 FlowRange    uint8
14767                                 DrownDmg     uint8
14768                                 Floodable    bool
14769
14770                                 DrawBox, ColBox, SelBox NodeBox
14771
14772                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14773
14774                                 LegacyFaceDir bool
14775                                 LegacyMounted bool
14776
14777                                 DigPredict string
14778
14779                                 MaxLvl uint8
14780
14781                                 AlphaUse
14782                         }))(obj)).P1Type).serialize(w)
14783                 }); err != nil {
14784                         if err == io.EOF {
14785                                 chk(io.EOF)
14786                         }
14787                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
14788                 }
14789                 if err := pcall(func() {
14790                         ((*(*(struct {
14791                                 Param0 Content
14792
14793                                 Name   string
14794                                 Groups []Group
14795
14796                                 P1Type   Param1Type
14797                                 P2Type   Param2Type
14798                                 DrawType DrawType
14799
14800                                 Mesh  string
14801                                 Scale float32
14802                                 //mt:const uint8(6)
14803                                 Tiles        [6]TileDef
14804                                 OverlayTiles [6]TileDef
14805                                 //mt:const uint8(6)
14806                                 SpecialTiles [6]TileDef
14807
14808                                 Color   color.NRGBA
14809                                 Palette Texture
14810
14811                                 Waving       WaveType
14812                                 ConnectSides uint8
14813                                 ConnectTo    []Content
14814                                 InsideTint   color.NRGBA
14815                                 Level        uint8 // Must be < 128.
14816
14817                                 Translucent bool // Sunlight is scattered and becomes normal light.
14818                                 Transparent bool // Sunlight isn't scattered.
14819                                 LightSrc    uint8
14820
14821                                 GndContent   bool
14822                                 Collides     bool
14823                                 Pointable    bool
14824                                 Diggable     bool
14825                                 Climbable    bool
14826                                 Replaceable  bool
14827                                 OnRightClick bool
14828
14829                                 DmgPerSec int32
14830
14831                                 LiquidType   LiquidType
14832                                 FlowingAlt   string
14833                                 SrcAlt       string
14834                                 Viscosity    uint8 // 0-7
14835                                 LiqRenewable bool
14836                                 FlowRange    uint8
14837                                 DrownDmg     uint8
14838                                 Floodable    bool
14839
14840                                 DrawBox, ColBox, SelBox NodeBox
14841
14842                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14843
14844                                 LegacyFaceDir bool
14845                                 LegacyMounted bool
14846
14847                                 DigPredict string
14848
14849                                 MaxLvl uint8
14850
14851                                 AlphaUse
14852                         }))(obj)).P2Type).serialize(w)
14853                 }); err != nil {
14854                         if err == io.EOF {
14855                                 chk(io.EOF)
14856                         }
14857                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
14858                 }
14859                 if err := pcall(func() {
14860                         ((*(*(struct {
14861                                 Param0 Content
14862
14863                                 Name   string
14864                                 Groups []Group
14865
14866                                 P1Type   Param1Type
14867                                 P2Type   Param2Type
14868                                 DrawType DrawType
14869
14870                                 Mesh  string
14871                                 Scale float32
14872                                 //mt:const uint8(6)
14873                                 Tiles        [6]TileDef
14874                                 OverlayTiles [6]TileDef
14875                                 //mt:const uint8(6)
14876                                 SpecialTiles [6]TileDef
14877
14878                                 Color   color.NRGBA
14879                                 Palette Texture
14880
14881                                 Waving       WaveType
14882                                 ConnectSides uint8
14883                                 ConnectTo    []Content
14884                                 InsideTint   color.NRGBA
14885                                 Level        uint8 // Must be < 128.
14886
14887                                 Translucent bool // Sunlight is scattered and becomes normal light.
14888                                 Transparent bool // Sunlight isn't scattered.
14889                                 LightSrc    uint8
14890
14891                                 GndContent   bool
14892                                 Collides     bool
14893                                 Pointable    bool
14894                                 Diggable     bool
14895                                 Climbable    bool
14896                                 Replaceable  bool
14897                                 OnRightClick bool
14898
14899                                 DmgPerSec int32
14900
14901                                 LiquidType   LiquidType
14902                                 FlowingAlt   string
14903                                 SrcAlt       string
14904                                 Viscosity    uint8 // 0-7
14905                                 LiqRenewable bool
14906                                 FlowRange    uint8
14907                                 DrownDmg     uint8
14908                                 Floodable    bool
14909
14910                                 DrawBox, ColBox, SelBox NodeBox
14911
14912                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14913
14914                                 LegacyFaceDir bool
14915                                 LegacyMounted bool
14916
14917                                 DigPredict string
14918
14919                                 MaxLvl uint8
14920
14921                                 AlphaUse
14922                         }))(obj)).DrawType).serialize(w)
14923                 }); err != nil {
14924                         if err == io.EOF {
14925                                 chk(io.EOF)
14926                         }
14927                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
14928                 }
14929                 if len(([]byte((*(*(struct {
14930                         Param0 Content
14931
14932                         Name   string
14933                         Groups []Group
14934
14935                         P1Type   Param1Type
14936                         P2Type   Param2Type
14937                         DrawType DrawType
14938
14939                         Mesh  string
14940                         Scale float32
14941                         //mt:const uint8(6)
14942                         Tiles        [6]TileDef
14943                         OverlayTiles [6]TileDef
14944                         //mt:const uint8(6)
14945                         SpecialTiles [6]TileDef
14946
14947                         Color   color.NRGBA
14948                         Palette Texture
14949
14950                         Waving       WaveType
14951                         ConnectSides uint8
14952                         ConnectTo    []Content
14953                         InsideTint   color.NRGBA
14954                         Level        uint8 // Must be < 128.
14955
14956                         Translucent bool // Sunlight is scattered and becomes normal light.
14957                         Transparent bool // Sunlight isn't scattered.
14958                         LightSrc    uint8
14959
14960                         GndContent   bool
14961                         Collides     bool
14962                         Pointable    bool
14963                         Diggable     bool
14964                         Climbable    bool
14965                         Replaceable  bool
14966                         OnRightClick bool
14967
14968                         DmgPerSec int32
14969
14970                         LiquidType   LiquidType
14971                         FlowingAlt   string
14972                         SrcAlt       string
14973                         Viscosity    uint8 // 0-7
14974                         LiqRenewable bool
14975                         FlowRange    uint8
14976                         DrownDmg     uint8
14977                         Floodable    bool
14978
14979                         DrawBox, ColBox, SelBox NodeBox
14980
14981                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14982
14983                         LegacyFaceDir bool
14984                         LegacyMounted bool
14985
14986                         DigPredict string
14987
14988                         MaxLvl uint8
14989
14990                         AlphaUse
14991                 }))(obj)).Mesh))) > math.MaxUint16 {
14992                         chk(ErrTooLong)
14993                 }
14994                 {
14995                         x := uint16(len(([]byte((*(*(struct {
14996                                 Param0 Content
14997
14998                                 Name   string
14999                                 Groups []Group
15000
15001                                 P1Type   Param1Type
15002                                 P2Type   Param2Type
15003                                 DrawType DrawType
15004
15005                                 Mesh  string
15006                                 Scale float32
15007                                 //mt:const uint8(6)
15008                                 Tiles        [6]TileDef
15009                                 OverlayTiles [6]TileDef
15010                                 //mt:const uint8(6)
15011                                 SpecialTiles [6]TileDef
15012
15013                                 Color   color.NRGBA
15014                                 Palette Texture
15015
15016                                 Waving       WaveType
15017                                 ConnectSides uint8
15018                                 ConnectTo    []Content
15019                                 InsideTint   color.NRGBA
15020                                 Level        uint8 // Must be < 128.
15021
15022                                 Translucent bool // Sunlight is scattered and becomes normal light.
15023                                 Transparent bool // Sunlight isn't scattered.
15024                                 LightSrc    uint8
15025
15026                                 GndContent   bool
15027                                 Collides     bool
15028                                 Pointable    bool
15029                                 Diggable     bool
15030                                 Climbable    bool
15031                                 Replaceable  bool
15032                                 OnRightClick bool
15033
15034                                 DmgPerSec int32
15035
15036                                 LiquidType   LiquidType
15037                                 FlowingAlt   string
15038                                 SrcAlt       string
15039                                 Viscosity    uint8 // 0-7
15040                                 LiqRenewable bool
15041                                 FlowRange    uint8
15042                                 DrownDmg     uint8
15043                                 Floodable    bool
15044
15045                                 DrawBox, ColBox, SelBox NodeBox
15046
15047                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15048
15049                                 LegacyFaceDir bool
15050                                 LegacyMounted bool
15051
15052                                 DigPredict string
15053
15054                                 MaxLvl uint8
15055
15056                                 AlphaUse
15057                         }))(obj)).Mesh))))
15058                         write16(w, uint16(x))
15059                 }
15060                 {
15061                         _, err := w.Write(([]byte((*(*(struct {
15062                                 Param0 Content
15063
15064                                 Name   string
15065                                 Groups []Group
15066
15067                                 P1Type   Param1Type
15068                                 P2Type   Param2Type
15069                                 DrawType DrawType
15070
15071                                 Mesh  string
15072                                 Scale float32
15073                                 //mt:const uint8(6)
15074                                 Tiles        [6]TileDef
15075                                 OverlayTiles [6]TileDef
15076                                 //mt:const uint8(6)
15077                                 SpecialTiles [6]TileDef
15078
15079                                 Color   color.NRGBA
15080                                 Palette Texture
15081
15082                                 Waving       WaveType
15083                                 ConnectSides uint8
15084                                 ConnectTo    []Content
15085                                 InsideTint   color.NRGBA
15086                                 Level        uint8 // Must be < 128.
15087
15088                                 Translucent bool // Sunlight is scattered and becomes normal light.
15089                                 Transparent bool // Sunlight isn't scattered.
15090                                 LightSrc    uint8
15091
15092                                 GndContent   bool
15093                                 Collides     bool
15094                                 Pointable    bool
15095                                 Diggable     bool
15096                                 Climbable    bool
15097                                 Replaceable  bool
15098                                 OnRightClick bool
15099
15100                                 DmgPerSec int32
15101
15102                                 LiquidType   LiquidType
15103                                 FlowingAlt   string
15104                                 SrcAlt       string
15105                                 Viscosity    uint8 // 0-7
15106                                 LiqRenewable bool
15107                                 FlowRange    uint8
15108                                 DrownDmg     uint8
15109                                 Floodable    bool
15110
15111                                 DrawBox, ColBox, SelBox NodeBox
15112
15113                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15114
15115                                 LegacyFaceDir bool
15116                                 LegacyMounted bool
15117
15118                                 DigPredict string
15119
15120                                 MaxLvl uint8
15121
15122                                 AlphaUse
15123                         }))(obj)).Mesh))[:])
15124                         chk(err)
15125                 }
15126                 {
15127                         x := (*(*(struct {
15128                                 Param0 Content
15129
15130                                 Name   string
15131                                 Groups []Group
15132
15133                                 P1Type   Param1Type
15134                                 P2Type   Param2Type
15135                                 DrawType DrawType
15136
15137                                 Mesh  string
15138                                 Scale float32
15139                                 //mt:const uint8(6)
15140                                 Tiles        [6]TileDef
15141                                 OverlayTiles [6]TileDef
15142                                 //mt:const uint8(6)
15143                                 SpecialTiles [6]TileDef
15144
15145                                 Color   color.NRGBA
15146                                 Palette Texture
15147
15148                                 Waving       WaveType
15149                                 ConnectSides uint8
15150                                 ConnectTo    []Content
15151                                 InsideTint   color.NRGBA
15152                                 Level        uint8 // Must be < 128.
15153
15154                                 Translucent bool // Sunlight is scattered and becomes normal light.
15155                                 Transparent bool // Sunlight isn't scattered.
15156                                 LightSrc    uint8
15157
15158                                 GndContent   bool
15159                                 Collides     bool
15160                                 Pointable    bool
15161                                 Diggable     bool
15162                                 Climbable    bool
15163                                 Replaceable  bool
15164                                 OnRightClick bool
15165
15166                                 DmgPerSec int32
15167
15168                                 LiquidType   LiquidType
15169                                 FlowingAlt   string
15170                                 SrcAlt       string
15171                                 Viscosity    uint8 // 0-7
15172                                 LiqRenewable bool
15173                                 FlowRange    uint8
15174                                 DrownDmg     uint8
15175                                 Floodable    bool
15176
15177                                 DrawBox, ColBox, SelBox NodeBox
15178
15179                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15180
15181                                 LegacyFaceDir bool
15182                                 LegacyMounted bool
15183
15184                                 DigPredict string
15185
15186                                 MaxLvl uint8
15187
15188                                 AlphaUse
15189                         }))(obj)).Scale
15190                         write32(w, math.Float32bits(x))
15191                 }
15192                 {
15193                         local240 := uint8(6)
15194                         {
15195                                 x := local240
15196                                 write8(w, uint8(x))
15197                         }
15198                 }
15199                 for local241 := range (*(*(struct {
15200                         Param0 Content
15201
15202                         Name   string
15203                         Groups []Group
15204
15205                         P1Type   Param1Type
15206                         P2Type   Param2Type
15207                         DrawType DrawType
15208
15209                         Mesh  string
15210                         Scale float32
15211                         //mt:const uint8(6)
15212                         Tiles        [6]TileDef
15213                         OverlayTiles [6]TileDef
15214                         //mt:const uint8(6)
15215                         SpecialTiles [6]TileDef
15216
15217                         Color   color.NRGBA
15218                         Palette Texture
15219
15220                         Waving       WaveType
15221                         ConnectSides uint8
15222                         ConnectTo    []Content
15223                         InsideTint   color.NRGBA
15224                         Level        uint8 // Must be < 128.
15225
15226                         Translucent bool // Sunlight is scattered and becomes normal light.
15227                         Transparent bool // Sunlight isn't scattered.
15228                         LightSrc    uint8
15229
15230                         GndContent   bool
15231                         Collides     bool
15232                         Pointable    bool
15233                         Diggable     bool
15234                         Climbable    bool
15235                         Replaceable  bool
15236                         OnRightClick bool
15237
15238                         DmgPerSec int32
15239
15240                         LiquidType   LiquidType
15241                         FlowingAlt   string
15242                         SrcAlt       string
15243                         Viscosity    uint8 // 0-7
15244                         LiqRenewable bool
15245                         FlowRange    uint8
15246                         DrownDmg     uint8
15247                         Floodable    bool
15248
15249                         DrawBox, ColBox, SelBox NodeBox
15250
15251                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15252
15253                         LegacyFaceDir bool
15254                         LegacyMounted bool
15255
15256                         DigPredict string
15257
15258                         MaxLvl uint8
15259
15260                         AlphaUse
15261                 }))(obj)).Tiles {
15262                         if err := pcall(func() {
15263                                 (((*(*(struct {
15264                                         Param0 Content
15265
15266                                         Name   string
15267                                         Groups []Group
15268
15269                                         P1Type   Param1Type
15270                                         P2Type   Param2Type
15271                                         DrawType DrawType
15272
15273                                         Mesh  string
15274                                         Scale float32
15275                                         //mt:const uint8(6)
15276                                         Tiles        [6]TileDef
15277                                         OverlayTiles [6]TileDef
15278                                         //mt:const uint8(6)
15279                                         SpecialTiles [6]TileDef
15280
15281                                         Color   color.NRGBA
15282                                         Palette Texture
15283
15284                                         Waving       WaveType
15285                                         ConnectSides uint8
15286                                         ConnectTo    []Content
15287                                         InsideTint   color.NRGBA
15288                                         Level        uint8 // Must be < 128.
15289
15290                                         Translucent bool // Sunlight is scattered and becomes normal light.
15291                                         Transparent bool // Sunlight isn't scattered.
15292                                         LightSrc    uint8
15293
15294                                         GndContent   bool
15295                                         Collides     bool
15296                                         Pointable    bool
15297                                         Diggable     bool
15298                                         Climbable    bool
15299                                         Replaceable  bool
15300                                         OnRightClick bool
15301
15302                                         DmgPerSec int32
15303
15304                                         LiquidType   LiquidType
15305                                         FlowingAlt   string
15306                                         SrcAlt       string
15307                                         Viscosity    uint8 // 0-7
15308                                         LiqRenewable bool
15309                                         FlowRange    uint8
15310                                         DrownDmg     uint8
15311                                         Floodable    bool
15312
15313                                         DrawBox, ColBox, SelBox NodeBox
15314
15315                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15316
15317                                         LegacyFaceDir bool
15318                                         LegacyMounted bool
15319
15320                                         DigPredict string
15321
15322                                         MaxLvl uint8
15323
15324                                         AlphaUse
15325                                 }))(obj)).Tiles)[local241]).serialize(w)
15326                         }); err != nil {
15327                                 if err == io.EOF {
15328                                         chk(io.EOF)
15329                                 }
15330                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15331                         }
15332                 }
15333                 for local242 := range (*(*(struct {
15334                         Param0 Content
15335
15336                         Name   string
15337                         Groups []Group
15338
15339                         P1Type   Param1Type
15340                         P2Type   Param2Type
15341                         DrawType DrawType
15342
15343                         Mesh  string
15344                         Scale float32
15345                         //mt:const uint8(6)
15346                         Tiles        [6]TileDef
15347                         OverlayTiles [6]TileDef
15348                         //mt:const uint8(6)
15349                         SpecialTiles [6]TileDef
15350
15351                         Color   color.NRGBA
15352                         Palette Texture
15353
15354                         Waving       WaveType
15355                         ConnectSides uint8
15356                         ConnectTo    []Content
15357                         InsideTint   color.NRGBA
15358                         Level        uint8 // Must be < 128.
15359
15360                         Translucent bool // Sunlight is scattered and becomes normal light.
15361                         Transparent bool // Sunlight isn't scattered.
15362                         LightSrc    uint8
15363
15364                         GndContent   bool
15365                         Collides     bool
15366                         Pointable    bool
15367                         Diggable     bool
15368                         Climbable    bool
15369                         Replaceable  bool
15370                         OnRightClick bool
15371
15372                         DmgPerSec int32
15373
15374                         LiquidType   LiquidType
15375                         FlowingAlt   string
15376                         SrcAlt       string
15377                         Viscosity    uint8 // 0-7
15378                         LiqRenewable bool
15379                         FlowRange    uint8
15380                         DrownDmg     uint8
15381                         Floodable    bool
15382
15383                         DrawBox, ColBox, SelBox NodeBox
15384
15385                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15386
15387                         LegacyFaceDir bool
15388                         LegacyMounted bool
15389
15390                         DigPredict string
15391
15392                         MaxLvl uint8
15393
15394                         AlphaUse
15395                 }))(obj)).OverlayTiles {
15396                         if err := pcall(func() {
15397                                 (((*(*(struct {
15398                                         Param0 Content
15399
15400                                         Name   string
15401                                         Groups []Group
15402
15403                                         P1Type   Param1Type
15404                                         P2Type   Param2Type
15405                                         DrawType DrawType
15406
15407                                         Mesh  string
15408                                         Scale float32
15409                                         //mt:const uint8(6)
15410                                         Tiles        [6]TileDef
15411                                         OverlayTiles [6]TileDef
15412                                         //mt:const uint8(6)
15413                                         SpecialTiles [6]TileDef
15414
15415                                         Color   color.NRGBA
15416                                         Palette Texture
15417
15418                                         Waving       WaveType
15419                                         ConnectSides uint8
15420                                         ConnectTo    []Content
15421                                         InsideTint   color.NRGBA
15422                                         Level        uint8 // Must be < 128.
15423
15424                                         Translucent bool // Sunlight is scattered and becomes normal light.
15425                                         Transparent bool // Sunlight isn't scattered.
15426                                         LightSrc    uint8
15427
15428                                         GndContent   bool
15429                                         Collides     bool
15430                                         Pointable    bool
15431                                         Diggable     bool
15432                                         Climbable    bool
15433                                         Replaceable  bool
15434                                         OnRightClick bool
15435
15436                                         DmgPerSec int32
15437
15438                                         LiquidType   LiquidType
15439                                         FlowingAlt   string
15440                                         SrcAlt       string
15441                                         Viscosity    uint8 // 0-7
15442                                         LiqRenewable bool
15443                                         FlowRange    uint8
15444                                         DrownDmg     uint8
15445                                         Floodable    bool
15446
15447                                         DrawBox, ColBox, SelBox NodeBox
15448
15449                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15450
15451                                         LegacyFaceDir bool
15452                                         LegacyMounted bool
15453
15454                                         DigPredict string
15455
15456                                         MaxLvl uint8
15457
15458                                         AlphaUse
15459                                 }))(obj)).OverlayTiles)[local242]).serialize(w)
15460                         }); err != nil {
15461                                 if err == io.EOF {
15462                                         chk(io.EOF)
15463                                 }
15464                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15465                         }
15466                 }
15467                 {
15468                         local243 := uint8(6)
15469                         {
15470                                 x := local243
15471                                 write8(w, uint8(x))
15472                         }
15473                 }
15474                 for local244 := range (*(*(struct {
15475                         Param0 Content
15476
15477                         Name   string
15478                         Groups []Group
15479
15480                         P1Type   Param1Type
15481                         P2Type   Param2Type
15482                         DrawType DrawType
15483
15484                         Mesh  string
15485                         Scale float32
15486                         //mt:const uint8(6)
15487                         Tiles        [6]TileDef
15488                         OverlayTiles [6]TileDef
15489                         //mt:const uint8(6)
15490                         SpecialTiles [6]TileDef
15491
15492                         Color   color.NRGBA
15493                         Palette Texture
15494
15495                         Waving       WaveType
15496                         ConnectSides uint8
15497                         ConnectTo    []Content
15498                         InsideTint   color.NRGBA
15499                         Level        uint8 // Must be < 128.
15500
15501                         Translucent bool // Sunlight is scattered and becomes normal light.
15502                         Transparent bool // Sunlight isn't scattered.
15503                         LightSrc    uint8
15504
15505                         GndContent   bool
15506                         Collides     bool
15507                         Pointable    bool
15508                         Diggable     bool
15509                         Climbable    bool
15510                         Replaceable  bool
15511                         OnRightClick bool
15512
15513                         DmgPerSec int32
15514
15515                         LiquidType   LiquidType
15516                         FlowingAlt   string
15517                         SrcAlt       string
15518                         Viscosity    uint8 // 0-7
15519                         LiqRenewable bool
15520                         FlowRange    uint8
15521                         DrownDmg     uint8
15522                         Floodable    bool
15523
15524                         DrawBox, ColBox, SelBox NodeBox
15525
15526                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15527
15528                         LegacyFaceDir bool
15529                         LegacyMounted bool
15530
15531                         DigPredict string
15532
15533                         MaxLvl uint8
15534
15535                         AlphaUse
15536                 }))(obj)).SpecialTiles {
15537                         if err := pcall(func() {
15538                                 (((*(*(struct {
15539                                         Param0 Content
15540
15541                                         Name   string
15542                                         Groups []Group
15543
15544                                         P1Type   Param1Type
15545                                         P2Type   Param2Type
15546                                         DrawType DrawType
15547
15548                                         Mesh  string
15549                                         Scale float32
15550                                         //mt:const uint8(6)
15551                                         Tiles        [6]TileDef
15552                                         OverlayTiles [6]TileDef
15553                                         //mt:const uint8(6)
15554                                         SpecialTiles [6]TileDef
15555
15556                                         Color   color.NRGBA
15557                                         Palette Texture
15558
15559                                         Waving       WaveType
15560                                         ConnectSides uint8
15561                                         ConnectTo    []Content
15562                                         InsideTint   color.NRGBA
15563                                         Level        uint8 // Must be < 128.
15564
15565                                         Translucent bool // Sunlight is scattered and becomes normal light.
15566                                         Transparent bool // Sunlight isn't scattered.
15567                                         LightSrc    uint8
15568
15569                                         GndContent   bool
15570                                         Collides     bool
15571                                         Pointable    bool
15572                                         Diggable     bool
15573                                         Climbable    bool
15574                                         Replaceable  bool
15575                                         OnRightClick bool
15576
15577                                         DmgPerSec int32
15578
15579                                         LiquidType   LiquidType
15580                                         FlowingAlt   string
15581                                         SrcAlt       string
15582                                         Viscosity    uint8 // 0-7
15583                                         LiqRenewable bool
15584                                         FlowRange    uint8
15585                                         DrownDmg     uint8
15586                                         Floodable    bool
15587
15588                                         DrawBox, ColBox, SelBox NodeBox
15589
15590                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15591
15592                                         LegacyFaceDir bool
15593                                         LegacyMounted bool
15594
15595                                         DigPredict string
15596
15597                                         MaxLvl uint8
15598
15599                                         AlphaUse
15600                                 }))(obj)).SpecialTiles)[local244]).serialize(w)
15601                         }); err != nil {
15602                                 if err == io.EOF {
15603                                         chk(io.EOF)
15604                                 }
15605                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15606                         }
15607                 }
15608                 {
15609                         x := (*(*(struct {
15610                                 Param0 Content
15611
15612                                 Name   string
15613                                 Groups []Group
15614
15615                                 P1Type   Param1Type
15616                                 P2Type   Param2Type
15617                                 DrawType DrawType
15618
15619                                 Mesh  string
15620                                 Scale float32
15621                                 //mt:const uint8(6)
15622                                 Tiles        [6]TileDef
15623                                 OverlayTiles [6]TileDef
15624                                 //mt:const uint8(6)
15625                                 SpecialTiles [6]TileDef
15626
15627                                 Color   color.NRGBA
15628                                 Palette Texture
15629
15630                                 Waving       WaveType
15631                                 ConnectSides uint8
15632                                 ConnectTo    []Content
15633                                 InsideTint   color.NRGBA
15634                                 Level        uint8 // Must be < 128.
15635
15636                                 Translucent bool // Sunlight is scattered and becomes normal light.
15637                                 Transparent bool // Sunlight isn't scattered.
15638                                 LightSrc    uint8
15639
15640                                 GndContent   bool
15641                                 Collides     bool
15642                                 Pointable    bool
15643                                 Diggable     bool
15644                                 Climbable    bool
15645                                 Replaceable  bool
15646                                 OnRightClick bool
15647
15648                                 DmgPerSec int32
15649
15650                                 LiquidType   LiquidType
15651                                 FlowingAlt   string
15652                                 SrcAlt       string
15653                                 Viscosity    uint8 // 0-7
15654                                 LiqRenewable bool
15655                                 FlowRange    uint8
15656                                 DrownDmg     uint8
15657                                 Floodable    bool
15658
15659                                 DrawBox, ColBox, SelBox NodeBox
15660
15661                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15662
15663                                 LegacyFaceDir bool
15664                                 LegacyMounted bool
15665
15666                                 DigPredict string
15667
15668                                 MaxLvl uint8
15669
15670                                 AlphaUse
15671                         }))(obj)).Color
15672                         w.Write([]byte{x.A, x.R, x.G, x.B})
15673                 }
15674                 if err := pcall(func() {
15675                         ((*(*(struct {
15676                                 Param0 Content
15677
15678                                 Name   string
15679                                 Groups []Group
15680
15681                                 P1Type   Param1Type
15682                                 P2Type   Param2Type
15683                                 DrawType DrawType
15684
15685                                 Mesh  string
15686                                 Scale float32
15687                                 //mt:const uint8(6)
15688                                 Tiles        [6]TileDef
15689                                 OverlayTiles [6]TileDef
15690                                 //mt:const uint8(6)
15691                                 SpecialTiles [6]TileDef
15692
15693                                 Color   color.NRGBA
15694                                 Palette Texture
15695
15696                                 Waving       WaveType
15697                                 ConnectSides uint8
15698                                 ConnectTo    []Content
15699                                 InsideTint   color.NRGBA
15700                                 Level        uint8 // Must be < 128.
15701
15702                                 Translucent bool // Sunlight is scattered and becomes normal light.
15703                                 Transparent bool // Sunlight isn't scattered.
15704                                 LightSrc    uint8
15705
15706                                 GndContent   bool
15707                                 Collides     bool
15708                                 Pointable    bool
15709                                 Diggable     bool
15710                                 Climbable    bool
15711                                 Replaceable  bool
15712                                 OnRightClick bool
15713
15714                                 DmgPerSec int32
15715
15716                                 LiquidType   LiquidType
15717                                 FlowingAlt   string
15718                                 SrcAlt       string
15719                                 Viscosity    uint8 // 0-7
15720                                 LiqRenewable bool
15721                                 FlowRange    uint8
15722                                 DrownDmg     uint8
15723                                 Floodable    bool
15724
15725                                 DrawBox, ColBox, SelBox NodeBox
15726
15727                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15728
15729                                 LegacyFaceDir bool
15730                                 LegacyMounted bool
15731
15732                                 DigPredict string
15733
15734                                 MaxLvl uint8
15735
15736                                 AlphaUse
15737                         }))(obj)).Palette).serialize(w)
15738                 }); err != nil {
15739                         if err == io.EOF {
15740                                 chk(io.EOF)
15741                         }
15742                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
15743                 }
15744                 if err := pcall(func() {
15745                         ((*(*(struct {
15746                                 Param0 Content
15747
15748                                 Name   string
15749                                 Groups []Group
15750
15751                                 P1Type   Param1Type
15752                                 P2Type   Param2Type
15753                                 DrawType DrawType
15754
15755                                 Mesh  string
15756                                 Scale float32
15757                                 //mt:const uint8(6)
15758                                 Tiles        [6]TileDef
15759                                 OverlayTiles [6]TileDef
15760                                 //mt:const uint8(6)
15761                                 SpecialTiles [6]TileDef
15762
15763                                 Color   color.NRGBA
15764                                 Palette Texture
15765
15766                                 Waving       WaveType
15767                                 ConnectSides uint8
15768                                 ConnectTo    []Content
15769                                 InsideTint   color.NRGBA
15770                                 Level        uint8 // Must be < 128.
15771
15772                                 Translucent bool // Sunlight is scattered and becomes normal light.
15773                                 Transparent bool // Sunlight isn't scattered.
15774                                 LightSrc    uint8
15775
15776                                 GndContent   bool
15777                                 Collides     bool
15778                                 Pointable    bool
15779                                 Diggable     bool
15780                                 Climbable    bool
15781                                 Replaceable  bool
15782                                 OnRightClick bool
15783
15784                                 DmgPerSec int32
15785
15786                                 LiquidType   LiquidType
15787                                 FlowingAlt   string
15788                                 SrcAlt       string
15789                                 Viscosity    uint8 // 0-7
15790                                 LiqRenewable bool
15791                                 FlowRange    uint8
15792                                 DrownDmg     uint8
15793                                 Floodable    bool
15794
15795                                 DrawBox, ColBox, SelBox NodeBox
15796
15797                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15798
15799                                 LegacyFaceDir bool
15800                                 LegacyMounted bool
15801
15802                                 DigPredict string
15803
15804                                 MaxLvl uint8
15805
15806                                 AlphaUse
15807                         }))(obj)).Waving).serialize(w)
15808                 }); err != nil {
15809                         if err == io.EOF {
15810                                 chk(io.EOF)
15811                         }
15812                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
15813                 }
15814                 {
15815                         x := (*(*(struct {
15816                                 Param0 Content
15817
15818                                 Name   string
15819                                 Groups []Group
15820
15821                                 P1Type   Param1Type
15822                                 P2Type   Param2Type
15823                                 DrawType DrawType
15824
15825                                 Mesh  string
15826                                 Scale float32
15827                                 //mt:const uint8(6)
15828                                 Tiles        [6]TileDef
15829                                 OverlayTiles [6]TileDef
15830                                 //mt:const uint8(6)
15831                                 SpecialTiles [6]TileDef
15832
15833                                 Color   color.NRGBA
15834                                 Palette Texture
15835
15836                                 Waving       WaveType
15837                                 ConnectSides uint8
15838                                 ConnectTo    []Content
15839                                 InsideTint   color.NRGBA
15840                                 Level        uint8 // Must be < 128.
15841
15842                                 Translucent bool // Sunlight is scattered and becomes normal light.
15843                                 Transparent bool // Sunlight isn't scattered.
15844                                 LightSrc    uint8
15845
15846                                 GndContent   bool
15847                                 Collides     bool
15848                                 Pointable    bool
15849                                 Diggable     bool
15850                                 Climbable    bool
15851                                 Replaceable  bool
15852                                 OnRightClick bool
15853
15854                                 DmgPerSec int32
15855
15856                                 LiquidType   LiquidType
15857                                 FlowingAlt   string
15858                                 SrcAlt       string
15859                                 Viscosity    uint8 // 0-7
15860                                 LiqRenewable bool
15861                                 FlowRange    uint8
15862                                 DrownDmg     uint8
15863                                 Floodable    bool
15864
15865                                 DrawBox, ColBox, SelBox NodeBox
15866
15867                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15868
15869                                 LegacyFaceDir bool
15870                                 LegacyMounted bool
15871
15872                                 DigPredict string
15873
15874                                 MaxLvl uint8
15875
15876                                 AlphaUse
15877                         }))(obj)).ConnectSides
15878                         write8(w, uint8(x))
15879                 }
15880                 if len(((*(*(struct {
15881                         Param0 Content
15882
15883                         Name   string
15884                         Groups []Group
15885
15886                         P1Type   Param1Type
15887                         P2Type   Param2Type
15888                         DrawType DrawType
15889
15890                         Mesh  string
15891                         Scale float32
15892                         //mt:const uint8(6)
15893                         Tiles        [6]TileDef
15894                         OverlayTiles [6]TileDef
15895                         //mt:const uint8(6)
15896                         SpecialTiles [6]TileDef
15897
15898                         Color   color.NRGBA
15899                         Palette Texture
15900
15901                         Waving       WaveType
15902                         ConnectSides uint8
15903                         ConnectTo    []Content
15904                         InsideTint   color.NRGBA
15905                         Level        uint8 // Must be < 128.
15906
15907                         Translucent bool // Sunlight is scattered and becomes normal light.
15908                         Transparent bool // Sunlight isn't scattered.
15909                         LightSrc    uint8
15910
15911                         GndContent   bool
15912                         Collides     bool
15913                         Pointable    bool
15914                         Diggable     bool
15915                         Climbable    bool
15916                         Replaceable  bool
15917                         OnRightClick bool
15918
15919                         DmgPerSec int32
15920
15921                         LiquidType   LiquidType
15922                         FlowingAlt   string
15923                         SrcAlt       string
15924                         Viscosity    uint8 // 0-7
15925                         LiqRenewable bool
15926                         FlowRange    uint8
15927                         DrownDmg     uint8
15928                         Floodable    bool
15929
15930                         DrawBox, ColBox, SelBox NodeBox
15931
15932                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15933
15934                         LegacyFaceDir bool
15935                         LegacyMounted bool
15936
15937                         DigPredict string
15938
15939                         MaxLvl uint8
15940
15941                         AlphaUse
15942                 }))(obj)).ConnectTo)) > math.MaxUint16 {
15943                         chk(ErrTooLong)
15944                 }
15945                 {
15946                         x := uint16(len(((*(*(struct {
15947                                 Param0 Content
15948
15949                                 Name   string
15950                                 Groups []Group
15951
15952                                 P1Type   Param1Type
15953                                 P2Type   Param2Type
15954                                 DrawType DrawType
15955
15956                                 Mesh  string
15957                                 Scale float32
15958                                 //mt:const uint8(6)
15959                                 Tiles        [6]TileDef
15960                                 OverlayTiles [6]TileDef
15961                                 //mt:const uint8(6)
15962                                 SpecialTiles [6]TileDef
15963
15964                                 Color   color.NRGBA
15965                                 Palette Texture
15966
15967                                 Waving       WaveType
15968                                 ConnectSides uint8
15969                                 ConnectTo    []Content
15970                                 InsideTint   color.NRGBA
15971                                 Level        uint8 // Must be < 128.
15972
15973                                 Translucent bool // Sunlight is scattered and becomes normal light.
15974                                 Transparent bool // Sunlight isn't scattered.
15975                                 LightSrc    uint8
15976
15977                                 GndContent   bool
15978                                 Collides     bool
15979                                 Pointable    bool
15980                                 Diggable     bool
15981                                 Climbable    bool
15982                                 Replaceable  bool
15983                                 OnRightClick bool
15984
15985                                 DmgPerSec int32
15986
15987                                 LiquidType   LiquidType
15988                                 FlowingAlt   string
15989                                 SrcAlt       string
15990                                 Viscosity    uint8 // 0-7
15991                                 LiqRenewable bool
15992                                 FlowRange    uint8
15993                                 DrownDmg     uint8
15994                                 Floodable    bool
15995
15996                                 DrawBox, ColBox, SelBox NodeBox
15997
15998                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15999
16000                                 LegacyFaceDir bool
16001                                 LegacyMounted bool
16002
16003                                 DigPredict string
16004
16005                                 MaxLvl uint8
16006
16007                                 AlphaUse
16008                         }))(obj)).ConnectTo)))
16009                         write16(w, uint16(x))
16010                 }
16011                 for local245 := range (*(*(struct {
16012                         Param0 Content
16013
16014                         Name   string
16015                         Groups []Group
16016
16017                         P1Type   Param1Type
16018                         P2Type   Param2Type
16019                         DrawType DrawType
16020
16021                         Mesh  string
16022                         Scale float32
16023                         //mt:const uint8(6)
16024                         Tiles        [6]TileDef
16025                         OverlayTiles [6]TileDef
16026                         //mt:const uint8(6)
16027                         SpecialTiles [6]TileDef
16028
16029                         Color   color.NRGBA
16030                         Palette Texture
16031
16032                         Waving       WaveType
16033                         ConnectSides uint8
16034                         ConnectTo    []Content
16035                         InsideTint   color.NRGBA
16036                         Level        uint8 // Must be < 128.
16037
16038                         Translucent bool // Sunlight is scattered and becomes normal light.
16039                         Transparent bool // Sunlight isn't scattered.
16040                         LightSrc    uint8
16041
16042                         GndContent   bool
16043                         Collides     bool
16044                         Pointable    bool
16045                         Diggable     bool
16046                         Climbable    bool
16047                         Replaceable  bool
16048                         OnRightClick bool
16049
16050                         DmgPerSec int32
16051
16052                         LiquidType   LiquidType
16053                         FlowingAlt   string
16054                         SrcAlt       string
16055                         Viscosity    uint8 // 0-7
16056                         LiqRenewable bool
16057                         FlowRange    uint8
16058                         DrownDmg     uint8
16059                         Floodable    bool
16060
16061                         DrawBox, ColBox, SelBox NodeBox
16062
16063                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16064
16065                         LegacyFaceDir bool
16066                         LegacyMounted bool
16067
16068                         DigPredict string
16069
16070                         MaxLvl uint8
16071
16072                         AlphaUse
16073                 }))(obj)).ConnectTo {
16074                         if err := pcall(func() {
16075                                 (((*(*(struct {
16076                                         Param0 Content
16077
16078                                         Name   string
16079                                         Groups []Group
16080
16081                                         P1Type   Param1Type
16082                                         P2Type   Param2Type
16083                                         DrawType DrawType
16084
16085                                         Mesh  string
16086                                         Scale float32
16087                                         //mt:const uint8(6)
16088                                         Tiles        [6]TileDef
16089                                         OverlayTiles [6]TileDef
16090                                         //mt:const uint8(6)
16091                                         SpecialTiles [6]TileDef
16092
16093                                         Color   color.NRGBA
16094                                         Palette Texture
16095
16096                                         Waving       WaveType
16097                                         ConnectSides uint8
16098                                         ConnectTo    []Content
16099                                         InsideTint   color.NRGBA
16100                                         Level        uint8 // Must be < 128.
16101
16102                                         Translucent bool // Sunlight is scattered and becomes normal light.
16103                                         Transparent bool // Sunlight isn't scattered.
16104                                         LightSrc    uint8
16105
16106                                         GndContent   bool
16107                                         Collides     bool
16108                                         Pointable    bool
16109                                         Diggable     bool
16110                                         Climbable    bool
16111                                         Replaceable  bool
16112                                         OnRightClick bool
16113
16114                                         DmgPerSec int32
16115
16116                                         LiquidType   LiquidType
16117                                         FlowingAlt   string
16118                                         SrcAlt       string
16119                                         Viscosity    uint8 // 0-7
16120                                         LiqRenewable bool
16121                                         FlowRange    uint8
16122                                         DrownDmg     uint8
16123                                         Floodable    bool
16124
16125                                         DrawBox, ColBox, SelBox NodeBox
16126
16127                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16128
16129                                         LegacyFaceDir bool
16130                                         LegacyMounted bool
16131
16132                                         DigPredict string
16133
16134                                         MaxLvl uint8
16135
16136                                         AlphaUse
16137                                 }))(obj)).ConnectTo)[local245]).serialize(w)
16138                         }); err != nil {
16139                                 if err == io.EOF {
16140                                         chk(io.EOF)
16141                                 }
16142                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
16143                         }
16144                 }
16145                 {
16146                         x := (*(*(struct {
16147                                 Param0 Content
16148
16149                                 Name   string
16150                                 Groups []Group
16151
16152                                 P1Type   Param1Type
16153                                 P2Type   Param2Type
16154                                 DrawType DrawType
16155
16156                                 Mesh  string
16157                                 Scale float32
16158                                 //mt:const uint8(6)
16159                                 Tiles        [6]TileDef
16160                                 OverlayTiles [6]TileDef
16161                                 //mt:const uint8(6)
16162                                 SpecialTiles [6]TileDef
16163
16164                                 Color   color.NRGBA
16165                                 Palette Texture
16166
16167                                 Waving       WaveType
16168                                 ConnectSides uint8
16169                                 ConnectTo    []Content
16170                                 InsideTint   color.NRGBA
16171                                 Level        uint8 // Must be < 128.
16172
16173                                 Translucent bool // Sunlight is scattered and becomes normal light.
16174                                 Transparent bool // Sunlight isn't scattered.
16175                                 LightSrc    uint8
16176
16177                                 GndContent   bool
16178                                 Collides     bool
16179                                 Pointable    bool
16180                                 Diggable     bool
16181                                 Climbable    bool
16182                                 Replaceable  bool
16183                                 OnRightClick bool
16184
16185                                 DmgPerSec int32
16186
16187                                 LiquidType   LiquidType
16188                                 FlowingAlt   string
16189                                 SrcAlt       string
16190                                 Viscosity    uint8 // 0-7
16191                                 LiqRenewable bool
16192                                 FlowRange    uint8
16193                                 DrownDmg     uint8
16194                                 Floodable    bool
16195
16196                                 DrawBox, ColBox, SelBox NodeBox
16197
16198                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16199
16200                                 LegacyFaceDir bool
16201                                 LegacyMounted bool
16202
16203                                 DigPredict string
16204
16205                                 MaxLvl uint8
16206
16207                                 AlphaUse
16208                         }))(obj)).InsideTint
16209                         w.Write([]byte{x.A, x.R, x.G, x.B})
16210                 }
16211                 {
16212                         x := (*(*(struct {
16213                                 Param0 Content
16214
16215                                 Name   string
16216                                 Groups []Group
16217
16218                                 P1Type   Param1Type
16219                                 P2Type   Param2Type
16220                                 DrawType DrawType
16221
16222                                 Mesh  string
16223                                 Scale float32
16224                                 //mt:const uint8(6)
16225                                 Tiles        [6]TileDef
16226                                 OverlayTiles [6]TileDef
16227                                 //mt:const uint8(6)
16228                                 SpecialTiles [6]TileDef
16229
16230                                 Color   color.NRGBA
16231                                 Palette Texture
16232
16233                                 Waving       WaveType
16234                                 ConnectSides uint8
16235                                 ConnectTo    []Content
16236                                 InsideTint   color.NRGBA
16237                                 Level        uint8 // Must be < 128.
16238
16239                                 Translucent bool // Sunlight is scattered and becomes normal light.
16240                                 Transparent bool // Sunlight isn't scattered.
16241                                 LightSrc    uint8
16242
16243                                 GndContent   bool
16244                                 Collides     bool
16245                                 Pointable    bool
16246                                 Diggable     bool
16247                                 Climbable    bool
16248                                 Replaceable  bool
16249                                 OnRightClick bool
16250
16251                                 DmgPerSec int32
16252
16253                                 LiquidType   LiquidType
16254                                 FlowingAlt   string
16255                                 SrcAlt       string
16256                                 Viscosity    uint8 // 0-7
16257                                 LiqRenewable bool
16258                                 FlowRange    uint8
16259                                 DrownDmg     uint8
16260                                 Floodable    bool
16261
16262                                 DrawBox, ColBox, SelBox NodeBox
16263
16264                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16265
16266                                 LegacyFaceDir bool
16267                                 LegacyMounted bool
16268
16269                                 DigPredict string
16270
16271                                 MaxLvl uint8
16272
16273                                 AlphaUse
16274                         }))(obj)).Level
16275                         write8(w, uint8(x))
16276                 }
16277                 {
16278                         x := (*(*(struct {
16279                                 Param0 Content
16280
16281                                 Name   string
16282                                 Groups []Group
16283
16284                                 P1Type   Param1Type
16285                                 P2Type   Param2Type
16286                                 DrawType DrawType
16287
16288                                 Mesh  string
16289                                 Scale float32
16290                                 //mt:const uint8(6)
16291                                 Tiles        [6]TileDef
16292                                 OverlayTiles [6]TileDef
16293                                 //mt:const uint8(6)
16294                                 SpecialTiles [6]TileDef
16295
16296                                 Color   color.NRGBA
16297                                 Palette Texture
16298
16299                                 Waving       WaveType
16300                                 ConnectSides uint8
16301                                 ConnectTo    []Content
16302                                 InsideTint   color.NRGBA
16303                                 Level        uint8 // Must be < 128.
16304
16305                                 Translucent bool // Sunlight is scattered and becomes normal light.
16306                                 Transparent bool // Sunlight isn't scattered.
16307                                 LightSrc    uint8
16308
16309                                 GndContent   bool
16310                                 Collides     bool
16311                                 Pointable    bool
16312                                 Diggable     bool
16313                                 Climbable    bool
16314                                 Replaceable  bool
16315                                 OnRightClick bool
16316
16317                                 DmgPerSec int32
16318
16319                                 LiquidType   LiquidType
16320                                 FlowingAlt   string
16321                                 SrcAlt       string
16322                                 Viscosity    uint8 // 0-7
16323                                 LiqRenewable bool
16324                                 FlowRange    uint8
16325                                 DrownDmg     uint8
16326                                 Floodable    bool
16327
16328                                 DrawBox, ColBox, SelBox NodeBox
16329
16330                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16331
16332                                 LegacyFaceDir bool
16333                                 LegacyMounted bool
16334
16335                                 DigPredict string
16336
16337                                 MaxLvl uint8
16338
16339                                 AlphaUse
16340                         }))(obj)).Translucent
16341                         if x {
16342                                 write8(w, 1)
16343                         } else {
16344                                 write8(w, 0)
16345                         }
16346                 }
16347                 {
16348                         x := (*(*(struct {
16349                                 Param0 Content
16350
16351                                 Name   string
16352                                 Groups []Group
16353
16354                                 P1Type   Param1Type
16355                                 P2Type   Param2Type
16356                                 DrawType DrawType
16357
16358                                 Mesh  string
16359                                 Scale float32
16360                                 //mt:const uint8(6)
16361                                 Tiles        [6]TileDef
16362                                 OverlayTiles [6]TileDef
16363                                 //mt:const uint8(6)
16364                                 SpecialTiles [6]TileDef
16365
16366                                 Color   color.NRGBA
16367                                 Palette Texture
16368
16369                                 Waving       WaveType
16370                                 ConnectSides uint8
16371                                 ConnectTo    []Content
16372                                 InsideTint   color.NRGBA
16373                                 Level        uint8 // Must be < 128.
16374
16375                                 Translucent bool // Sunlight is scattered and becomes normal light.
16376                                 Transparent bool // Sunlight isn't scattered.
16377                                 LightSrc    uint8
16378
16379                                 GndContent   bool
16380                                 Collides     bool
16381                                 Pointable    bool
16382                                 Diggable     bool
16383                                 Climbable    bool
16384                                 Replaceable  bool
16385                                 OnRightClick bool
16386
16387                                 DmgPerSec int32
16388
16389                                 LiquidType   LiquidType
16390                                 FlowingAlt   string
16391                                 SrcAlt       string
16392                                 Viscosity    uint8 // 0-7
16393                                 LiqRenewable bool
16394                                 FlowRange    uint8
16395                                 DrownDmg     uint8
16396                                 Floodable    bool
16397
16398                                 DrawBox, ColBox, SelBox NodeBox
16399
16400                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16401
16402                                 LegacyFaceDir bool
16403                                 LegacyMounted bool
16404
16405                                 DigPredict string
16406
16407                                 MaxLvl uint8
16408
16409                                 AlphaUse
16410                         }))(obj)).Transparent
16411                         if x {
16412                                 write8(w, 1)
16413                         } else {
16414                                 write8(w, 0)
16415                         }
16416                 }
16417                 {
16418                         x := (*(*(struct {
16419                                 Param0 Content
16420
16421                                 Name   string
16422                                 Groups []Group
16423
16424                                 P1Type   Param1Type
16425                                 P2Type   Param2Type
16426                                 DrawType DrawType
16427
16428                                 Mesh  string
16429                                 Scale float32
16430                                 //mt:const uint8(6)
16431                                 Tiles        [6]TileDef
16432                                 OverlayTiles [6]TileDef
16433                                 //mt:const uint8(6)
16434                                 SpecialTiles [6]TileDef
16435
16436                                 Color   color.NRGBA
16437                                 Palette Texture
16438
16439                                 Waving       WaveType
16440                                 ConnectSides uint8
16441                                 ConnectTo    []Content
16442                                 InsideTint   color.NRGBA
16443                                 Level        uint8 // Must be < 128.
16444
16445                                 Translucent bool // Sunlight is scattered and becomes normal light.
16446                                 Transparent bool // Sunlight isn't scattered.
16447                                 LightSrc    uint8
16448
16449                                 GndContent   bool
16450                                 Collides     bool
16451                                 Pointable    bool
16452                                 Diggable     bool
16453                                 Climbable    bool
16454                                 Replaceable  bool
16455                                 OnRightClick bool
16456
16457                                 DmgPerSec int32
16458
16459                                 LiquidType   LiquidType
16460                                 FlowingAlt   string
16461                                 SrcAlt       string
16462                                 Viscosity    uint8 // 0-7
16463                                 LiqRenewable bool
16464                                 FlowRange    uint8
16465                                 DrownDmg     uint8
16466                                 Floodable    bool
16467
16468                                 DrawBox, ColBox, SelBox NodeBox
16469
16470                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16471
16472                                 LegacyFaceDir bool
16473                                 LegacyMounted bool
16474
16475                                 DigPredict string
16476
16477                                 MaxLvl uint8
16478
16479                                 AlphaUse
16480                         }))(obj)).LightSrc
16481                         write8(w, uint8(x))
16482                 }
16483                 {
16484                         x := (*(*(struct {
16485                                 Param0 Content
16486
16487                                 Name   string
16488                                 Groups []Group
16489
16490                                 P1Type   Param1Type
16491                                 P2Type   Param2Type
16492                                 DrawType DrawType
16493
16494                                 Mesh  string
16495                                 Scale float32
16496                                 //mt:const uint8(6)
16497                                 Tiles        [6]TileDef
16498                                 OverlayTiles [6]TileDef
16499                                 //mt:const uint8(6)
16500                                 SpecialTiles [6]TileDef
16501
16502                                 Color   color.NRGBA
16503                                 Palette Texture
16504
16505                                 Waving       WaveType
16506                                 ConnectSides uint8
16507                                 ConnectTo    []Content
16508                                 InsideTint   color.NRGBA
16509                                 Level        uint8 // Must be < 128.
16510
16511                                 Translucent bool // Sunlight is scattered and becomes normal light.
16512                                 Transparent bool // Sunlight isn't scattered.
16513                                 LightSrc    uint8
16514
16515                                 GndContent   bool
16516                                 Collides     bool
16517                                 Pointable    bool
16518                                 Diggable     bool
16519                                 Climbable    bool
16520                                 Replaceable  bool
16521                                 OnRightClick bool
16522
16523                                 DmgPerSec int32
16524
16525                                 LiquidType   LiquidType
16526                                 FlowingAlt   string
16527                                 SrcAlt       string
16528                                 Viscosity    uint8 // 0-7
16529                                 LiqRenewable bool
16530                                 FlowRange    uint8
16531                                 DrownDmg     uint8
16532                                 Floodable    bool
16533
16534                                 DrawBox, ColBox, SelBox NodeBox
16535
16536                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16537
16538                                 LegacyFaceDir bool
16539                                 LegacyMounted bool
16540
16541                                 DigPredict string
16542
16543                                 MaxLvl uint8
16544
16545                                 AlphaUse
16546                         }))(obj)).GndContent
16547                         if x {
16548                                 write8(w, 1)
16549                         } else {
16550                                 write8(w, 0)
16551                         }
16552                 }
16553                 {
16554                         x := (*(*(struct {
16555                                 Param0 Content
16556
16557                                 Name   string
16558                                 Groups []Group
16559
16560                                 P1Type   Param1Type
16561                                 P2Type   Param2Type
16562                                 DrawType DrawType
16563
16564                                 Mesh  string
16565                                 Scale float32
16566                                 //mt:const uint8(6)
16567                                 Tiles        [6]TileDef
16568                                 OverlayTiles [6]TileDef
16569                                 //mt:const uint8(6)
16570                                 SpecialTiles [6]TileDef
16571
16572                                 Color   color.NRGBA
16573                                 Palette Texture
16574
16575                                 Waving       WaveType
16576                                 ConnectSides uint8
16577                                 ConnectTo    []Content
16578                                 InsideTint   color.NRGBA
16579                                 Level        uint8 // Must be < 128.
16580
16581                                 Translucent bool // Sunlight is scattered and becomes normal light.
16582                                 Transparent bool // Sunlight isn't scattered.
16583                                 LightSrc    uint8
16584
16585                                 GndContent   bool
16586                                 Collides     bool
16587                                 Pointable    bool
16588                                 Diggable     bool
16589                                 Climbable    bool
16590                                 Replaceable  bool
16591                                 OnRightClick bool
16592
16593                                 DmgPerSec int32
16594
16595                                 LiquidType   LiquidType
16596                                 FlowingAlt   string
16597                                 SrcAlt       string
16598                                 Viscosity    uint8 // 0-7
16599                                 LiqRenewable bool
16600                                 FlowRange    uint8
16601                                 DrownDmg     uint8
16602                                 Floodable    bool
16603
16604                                 DrawBox, ColBox, SelBox NodeBox
16605
16606                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16607
16608                                 LegacyFaceDir bool
16609                                 LegacyMounted bool
16610
16611                                 DigPredict string
16612
16613                                 MaxLvl uint8
16614
16615                                 AlphaUse
16616                         }))(obj)).Collides
16617                         if x {
16618                                 write8(w, 1)
16619                         } else {
16620                                 write8(w, 0)
16621                         }
16622                 }
16623                 {
16624                         x := (*(*(struct {
16625                                 Param0 Content
16626
16627                                 Name   string
16628                                 Groups []Group
16629
16630                                 P1Type   Param1Type
16631                                 P2Type   Param2Type
16632                                 DrawType DrawType
16633
16634                                 Mesh  string
16635                                 Scale float32
16636                                 //mt:const uint8(6)
16637                                 Tiles        [6]TileDef
16638                                 OverlayTiles [6]TileDef
16639                                 //mt:const uint8(6)
16640                                 SpecialTiles [6]TileDef
16641
16642                                 Color   color.NRGBA
16643                                 Palette Texture
16644
16645                                 Waving       WaveType
16646                                 ConnectSides uint8
16647                                 ConnectTo    []Content
16648                                 InsideTint   color.NRGBA
16649                                 Level        uint8 // Must be < 128.
16650
16651                                 Translucent bool // Sunlight is scattered and becomes normal light.
16652                                 Transparent bool // Sunlight isn't scattered.
16653                                 LightSrc    uint8
16654
16655                                 GndContent   bool
16656                                 Collides     bool
16657                                 Pointable    bool
16658                                 Diggable     bool
16659                                 Climbable    bool
16660                                 Replaceable  bool
16661                                 OnRightClick bool
16662
16663                                 DmgPerSec int32
16664
16665                                 LiquidType   LiquidType
16666                                 FlowingAlt   string
16667                                 SrcAlt       string
16668                                 Viscosity    uint8 // 0-7
16669                                 LiqRenewable bool
16670                                 FlowRange    uint8
16671                                 DrownDmg     uint8
16672                                 Floodable    bool
16673
16674                                 DrawBox, ColBox, SelBox NodeBox
16675
16676                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16677
16678                                 LegacyFaceDir bool
16679                                 LegacyMounted bool
16680
16681                                 DigPredict string
16682
16683                                 MaxLvl uint8
16684
16685                                 AlphaUse
16686                         }))(obj)).Pointable
16687                         if x {
16688                                 write8(w, 1)
16689                         } else {
16690                                 write8(w, 0)
16691                         }
16692                 }
16693                 {
16694                         x := (*(*(struct {
16695                                 Param0 Content
16696
16697                                 Name   string
16698                                 Groups []Group
16699
16700                                 P1Type   Param1Type
16701                                 P2Type   Param2Type
16702                                 DrawType DrawType
16703
16704                                 Mesh  string
16705                                 Scale float32
16706                                 //mt:const uint8(6)
16707                                 Tiles        [6]TileDef
16708                                 OverlayTiles [6]TileDef
16709                                 //mt:const uint8(6)
16710                                 SpecialTiles [6]TileDef
16711
16712                                 Color   color.NRGBA
16713                                 Palette Texture
16714
16715                                 Waving       WaveType
16716                                 ConnectSides uint8
16717                                 ConnectTo    []Content
16718                                 InsideTint   color.NRGBA
16719                                 Level        uint8 // Must be < 128.
16720
16721                                 Translucent bool // Sunlight is scattered and becomes normal light.
16722                                 Transparent bool // Sunlight isn't scattered.
16723                                 LightSrc    uint8
16724
16725                                 GndContent   bool
16726                                 Collides     bool
16727                                 Pointable    bool
16728                                 Diggable     bool
16729                                 Climbable    bool
16730                                 Replaceable  bool
16731                                 OnRightClick bool
16732
16733                                 DmgPerSec int32
16734
16735                                 LiquidType   LiquidType
16736                                 FlowingAlt   string
16737                                 SrcAlt       string
16738                                 Viscosity    uint8 // 0-7
16739                                 LiqRenewable bool
16740                                 FlowRange    uint8
16741                                 DrownDmg     uint8
16742                                 Floodable    bool
16743
16744                                 DrawBox, ColBox, SelBox NodeBox
16745
16746                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16747
16748                                 LegacyFaceDir bool
16749                                 LegacyMounted bool
16750
16751                                 DigPredict string
16752
16753                                 MaxLvl uint8
16754
16755                                 AlphaUse
16756                         }))(obj)).Diggable
16757                         if x {
16758                                 write8(w, 1)
16759                         } else {
16760                                 write8(w, 0)
16761                         }
16762                 }
16763                 {
16764                         x := (*(*(struct {
16765                                 Param0 Content
16766
16767                                 Name   string
16768                                 Groups []Group
16769
16770                                 P1Type   Param1Type
16771                                 P2Type   Param2Type
16772                                 DrawType DrawType
16773
16774                                 Mesh  string
16775                                 Scale float32
16776                                 //mt:const uint8(6)
16777                                 Tiles        [6]TileDef
16778                                 OverlayTiles [6]TileDef
16779                                 //mt:const uint8(6)
16780                                 SpecialTiles [6]TileDef
16781
16782                                 Color   color.NRGBA
16783                                 Palette Texture
16784
16785                                 Waving       WaveType
16786                                 ConnectSides uint8
16787                                 ConnectTo    []Content
16788                                 InsideTint   color.NRGBA
16789                                 Level        uint8 // Must be < 128.
16790
16791                                 Translucent bool // Sunlight is scattered and becomes normal light.
16792                                 Transparent bool // Sunlight isn't scattered.
16793                                 LightSrc    uint8
16794
16795                                 GndContent   bool
16796                                 Collides     bool
16797                                 Pointable    bool
16798                                 Diggable     bool
16799                                 Climbable    bool
16800                                 Replaceable  bool
16801                                 OnRightClick bool
16802
16803                                 DmgPerSec int32
16804
16805                                 LiquidType   LiquidType
16806                                 FlowingAlt   string
16807                                 SrcAlt       string
16808                                 Viscosity    uint8 // 0-7
16809                                 LiqRenewable bool
16810                                 FlowRange    uint8
16811                                 DrownDmg     uint8
16812                                 Floodable    bool
16813
16814                                 DrawBox, ColBox, SelBox NodeBox
16815
16816                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16817
16818                                 LegacyFaceDir bool
16819                                 LegacyMounted bool
16820
16821                                 DigPredict string
16822
16823                                 MaxLvl uint8
16824
16825                                 AlphaUse
16826                         }))(obj)).Climbable
16827                         if x {
16828                                 write8(w, 1)
16829                         } else {
16830                                 write8(w, 0)
16831                         }
16832                 }
16833                 {
16834                         x := (*(*(struct {
16835                                 Param0 Content
16836
16837                                 Name   string
16838                                 Groups []Group
16839
16840                                 P1Type   Param1Type
16841                                 P2Type   Param2Type
16842                                 DrawType DrawType
16843
16844                                 Mesh  string
16845                                 Scale float32
16846                                 //mt:const uint8(6)
16847                                 Tiles        [6]TileDef
16848                                 OverlayTiles [6]TileDef
16849                                 //mt:const uint8(6)
16850                                 SpecialTiles [6]TileDef
16851
16852                                 Color   color.NRGBA
16853                                 Palette Texture
16854
16855                                 Waving       WaveType
16856                                 ConnectSides uint8
16857                                 ConnectTo    []Content
16858                                 InsideTint   color.NRGBA
16859                                 Level        uint8 // Must be < 128.
16860
16861                                 Translucent bool // Sunlight is scattered and becomes normal light.
16862                                 Transparent bool // Sunlight isn't scattered.
16863                                 LightSrc    uint8
16864
16865                                 GndContent   bool
16866                                 Collides     bool
16867                                 Pointable    bool
16868                                 Diggable     bool
16869                                 Climbable    bool
16870                                 Replaceable  bool
16871                                 OnRightClick bool
16872
16873                                 DmgPerSec int32
16874
16875                                 LiquidType   LiquidType
16876                                 FlowingAlt   string
16877                                 SrcAlt       string
16878                                 Viscosity    uint8 // 0-7
16879                                 LiqRenewable bool
16880                                 FlowRange    uint8
16881                                 DrownDmg     uint8
16882                                 Floodable    bool
16883
16884                                 DrawBox, ColBox, SelBox NodeBox
16885
16886                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16887
16888                                 LegacyFaceDir bool
16889                                 LegacyMounted bool
16890
16891                                 DigPredict string
16892
16893                                 MaxLvl uint8
16894
16895                                 AlphaUse
16896                         }))(obj)).Replaceable
16897                         if x {
16898                                 write8(w, 1)
16899                         } else {
16900                                 write8(w, 0)
16901                         }
16902                 }
16903                 {
16904                         x := (*(*(struct {
16905                                 Param0 Content
16906
16907                                 Name   string
16908                                 Groups []Group
16909
16910                                 P1Type   Param1Type
16911                                 P2Type   Param2Type
16912                                 DrawType DrawType
16913
16914                                 Mesh  string
16915                                 Scale float32
16916                                 //mt:const uint8(6)
16917                                 Tiles        [6]TileDef
16918                                 OverlayTiles [6]TileDef
16919                                 //mt:const uint8(6)
16920                                 SpecialTiles [6]TileDef
16921
16922                                 Color   color.NRGBA
16923                                 Palette Texture
16924
16925                                 Waving       WaveType
16926                                 ConnectSides uint8
16927                                 ConnectTo    []Content
16928                                 InsideTint   color.NRGBA
16929                                 Level        uint8 // Must be < 128.
16930
16931                                 Translucent bool // Sunlight is scattered and becomes normal light.
16932                                 Transparent bool // Sunlight isn't scattered.
16933                                 LightSrc    uint8
16934
16935                                 GndContent   bool
16936                                 Collides     bool
16937                                 Pointable    bool
16938                                 Diggable     bool
16939                                 Climbable    bool
16940                                 Replaceable  bool
16941                                 OnRightClick bool
16942
16943                                 DmgPerSec int32
16944
16945                                 LiquidType   LiquidType
16946                                 FlowingAlt   string
16947                                 SrcAlt       string
16948                                 Viscosity    uint8 // 0-7
16949                                 LiqRenewable bool
16950                                 FlowRange    uint8
16951                                 DrownDmg     uint8
16952                                 Floodable    bool
16953
16954                                 DrawBox, ColBox, SelBox NodeBox
16955
16956                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16957
16958                                 LegacyFaceDir bool
16959                                 LegacyMounted bool
16960
16961                                 DigPredict string
16962
16963                                 MaxLvl uint8
16964
16965                                 AlphaUse
16966                         }))(obj)).OnRightClick
16967                         if x {
16968                                 write8(w, 1)
16969                         } else {
16970                                 write8(w, 0)
16971                         }
16972                 }
16973                 {
16974                         x := (*(*(struct {
16975                                 Param0 Content
16976
16977                                 Name   string
16978                                 Groups []Group
16979
16980                                 P1Type   Param1Type
16981                                 P2Type   Param2Type
16982                                 DrawType DrawType
16983
16984                                 Mesh  string
16985                                 Scale float32
16986                                 //mt:const uint8(6)
16987                                 Tiles        [6]TileDef
16988                                 OverlayTiles [6]TileDef
16989                                 //mt:const uint8(6)
16990                                 SpecialTiles [6]TileDef
16991
16992                                 Color   color.NRGBA
16993                                 Palette Texture
16994
16995                                 Waving       WaveType
16996                                 ConnectSides uint8
16997                                 ConnectTo    []Content
16998                                 InsideTint   color.NRGBA
16999                                 Level        uint8 // Must be < 128.
17000
17001                                 Translucent bool // Sunlight is scattered and becomes normal light.
17002                                 Transparent bool // Sunlight isn't scattered.
17003                                 LightSrc    uint8
17004
17005                                 GndContent   bool
17006                                 Collides     bool
17007                                 Pointable    bool
17008                                 Diggable     bool
17009                                 Climbable    bool
17010                                 Replaceable  bool
17011                                 OnRightClick bool
17012
17013                                 DmgPerSec int32
17014
17015                                 LiquidType   LiquidType
17016                                 FlowingAlt   string
17017                                 SrcAlt       string
17018                                 Viscosity    uint8 // 0-7
17019                                 LiqRenewable bool
17020                                 FlowRange    uint8
17021                                 DrownDmg     uint8
17022                                 Floodable    bool
17023
17024                                 DrawBox, ColBox, SelBox NodeBox
17025
17026                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17027
17028                                 LegacyFaceDir bool
17029                                 LegacyMounted bool
17030
17031                                 DigPredict string
17032
17033                                 MaxLvl uint8
17034
17035                                 AlphaUse
17036                         }))(obj)).DmgPerSec
17037                         write32(w, uint32(x))
17038                 }
17039                 if err := pcall(func() {
17040                         ((*(*(struct {
17041                                 Param0 Content
17042
17043                                 Name   string
17044                                 Groups []Group
17045
17046                                 P1Type   Param1Type
17047                                 P2Type   Param2Type
17048                                 DrawType DrawType
17049
17050                                 Mesh  string
17051                                 Scale float32
17052                                 //mt:const uint8(6)
17053                                 Tiles        [6]TileDef
17054                                 OverlayTiles [6]TileDef
17055                                 //mt:const uint8(6)
17056                                 SpecialTiles [6]TileDef
17057
17058                                 Color   color.NRGBA
17059                                 Palette Texture
17060
17061                                 Waving       WaveType
17062                                 ConnectSides uint8
17063                                 ConnectTo    []Content
17064                                 InsideTint   color.NRGBA
17065                                 Level        uint8 // Must be < 128.
17066
17067                                 Translucent bool // Sunlight is scattered and becomes normal light.
17068                                 Transparent bool // Sunlight isn't scattered.
17069                                 LightSrc    uint8
17070
17071                                 GndContent   bool
17072                                 Collides     bool
17073                                 Pointable    bool
17074                                 Diggable     bool
17075                                 Climbable    bool
17076                                 Replaceable  bool
17077                                 OnRightClick bool
17078
17079                                 DmgPerSec int32
17080
17081                                 LiquidType   LiquidType
17082                                 FlowingAlt   string
17083                                 SrcAlt       string
17084                                 Viscosity    uint8 // 0-7
17085                                 LiqRenewable bool
17086                                 FlowRange    uint8
17087                                 DrownDmg     uint8
17088                                 Floodable    bool
17089
17090                                 DrawBox, ColBox, SelBox NodeBox
17091
17092                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17093
17094                                 LegacyFaceDir bool
17095                                 LegacyMounted bool
17096
17097                                 DigPredict string
17098
17099                                 MaxLvl uint8
17100
17101                                 AlphaUse
17102                         }))(obj)).LiquidType).serialize(w)
17103                 }); err != nil {
17104                         if err == io.EOF {
17105                                 chk(io.EOF)
17106                         }
17107                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
17108                 }
17109                 if len(([]byte((*(*(struct {
17110                         Param0 Content
17111
17112                         Name   string
17113                         Groups []Group
17114
17115                         P1Type   Param1Type
17116                         P2Type   Param2Type
17117                         DrawType DrawType
17118
17119                         Mesh  string
17120                         Scale float32
17121                         //mt:const uint8(6)
17122                         Tiles        [6]TileDef
17123                         OverlayTiles [6]TileDef
17124                         //mt:const uint8(6)
17125                         SpecialTiles [6]TileDef
17126
17127                         Color   color.NRGBA
17128                         Palette Texture
17129
17130                         Waving       WaveType
17131                         ConnectSides uint8
17132                         ConnectTo    []Content
17133                         InsideTint   color.NRGBA
17134                         Level        uint8 // Must be < 128.
17135
17136                         Translucent bool // Sunlight is scattered and becomes normal light.
17137                         Transparent bool // Sunlight isn't scattered.
17138                         LightSrc    uint8
17139
17140                         GndContent   bool
17141                         Collides     bool
17142                         Pointable    bool
17143                         Diggable     bool
17144                         Climbable    bool
17145                         Replaceable  bool
17146                         OnRightClick bool
17147
17148                         DmgPerSec int32
17149
17150                         LiquidType   LiquidType
17151                         FlowingAlt   string
17152                         SrcAlt       string
17153                         Viscosity    uint8 // 0-7
17154                         LiqRenewable bool
17155                         FlowRange    uint8
17156                         DrownDmg     uint8
17157                         Floodable    bool
17158
17159                         DrawBox, ColBox, SelBox NodeBox
17160
17161                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17162
17163                         LegacyFaceDir bool
17164                         LegacyMounted bool
17165
17166                         DigPredict string
17167
17168                         MaxLvl uint8
17169
17170                         AlphaUse
17171                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
17172                         chk(ErrTooLong)
17173                 }
17174                 {
17175                         x := uint16(len(([]byte((*(*(struct {
17176                                 Param0 Content
17177
17178                                 Name   string
17179                                 Groups []Group
17180
17181                                 P1Type   Param1Type
17182                                 P2Type   Param2Type
17183                                 DrawType DrawType
17184
17185                                 Mesh  string
17186                                 Scale float32
17187                                 //mt:const uint8(6)
17188                                 Tiles        [6]TileDef
17189                                 OverlayTiles [6]TileDef
17190                                 //mt:const uint8(6)
17191                                 SpecialTiles [6]TileDef
17192
17193                                 Color   color.NRGBA
17194                                 Palette Texture
17195
17196                                 Waving       WaveType
17197                                 ConnectSides uint8
17198                                 ConnectTo    []Content
17199                                 InsideTint   color.NRGBA
17200                                 Level        uint8 // Must be < 128.
17201
17202                                 Translucent bool // Sunlight is scattered and becomes normal light.
17203                                 Transparent bool // Sunlight isn't scattered.
17204                                 LightSrc    uint8
17205
17206                                 GndContent   bool
17207                                 Collides     bool
17208                                 Pointable    bool
17209                                 Diggable     bool
17210                                 Climbable    bool
17211                                 Replaceable  bool
17212                                 OnRightClick bool
17213
17214                                 DmgPerSec int32
17215
17216                                 LiquidType   LiquidType
17217                                 FlowingAlt   string
17218                                 SrcAlt       string
17219                                 Viscosity    uint8 // 0-7
17220                                 LiqRenewable bool
17221                                 FlowRange    uint8
17222                                 DrownDmg     uint8
17223                                 Floodable    bool
17224
17225                                 DrawBox, ColBox, SelBox NodeBox
17226
17227                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17228
17229                                 LegacyFaceDir bool
17230                                 LegacyMounted bool
17231
17232                                 DigPredict string
17233
17234                                 MaxLvl uint8
17235
17236                                 AlphaUse
17237                         }))(obj)).FlowingAlt))))
17238                         write16(w, uint16(x))
17239                 }
17240                 {
17241                         _, err := w.Write(([]byte((*(*(struct {
17242                                 Param0 Content
17243
17244                                 Name   string
17245                                 Groups []Group
17246
17247                                 P1Type   Param1Type
17248                                 P2Type   Param2Type
17249                                 DrawType DrawType
17250
17251                                 Mesh  string
17252                                 Scale float32
17253                                 //mt:const uint8(6)
17254                                 Tiles        [6]TileDef
17255                                 OverlayTiles [6]TileDef
17256                                 //mt:const uint8(6)
17257                                 SpecialTiles [6]TileDef
17258
17259                                 Color   color.NRGBA
17260                                 Palette Texture
17261
17262                                 Waving       WaveType
17263                                 ConnectSides uint8
17264                                 ConnectTo    []Content
17265                                 InsideTint   color.NRGBA
17266                                 Level        uint8 // Must be < 128.
17267
17268                                 Translucent bool // Sunlight is scattered and becomes normal light.
17269                                 Transparent bool // Sunlight isn't scattered.
17270                                 LightSrc    uint8
17271
17272                                 GndContent   bool
17273                                 Collides     bool
17274                                 Pointable    bool
17275                                 Diggable     bool
17276                                 Climbable    bool
17277                                 Replaceable  bool
17278                                 OnRightClick bool
17279
17280                                 DmgPerSec int32
17281
17282                                 LiquidType   LiquidType
17283                                 FlowingAlt   string
17284                                 SrcAlt       string
17285                                 Viscosity    uint8 // 0-7
17286                                 LiqRenewable bool
17287                                 FlowRange    uint8
17288                                 DrownDmg     uint8
17289                                 Floodable    bool
17290
17291                                 DrawBox, ColBox, SelBox NodeBox
17292
17293                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17294
17295                                 LegacyFaceDir bool
17296                                 LegacyMounted bool
17297
17298                                 DigPredict string
17299
17300                                 MaxLvl uint8
17301
17302                                 AlphaUse
17303                         }))(obj)).FlowingAlt))[:])
17304                         chk(err)
17305                 }
17306                 if len(([]byte((*(*(struct {
17307                         Param0 Content
17308
17309                         Name   string
17310                         Groups []Group
17311
17312                         P1Type   Param1Type
17313                         P2Type   Param2Type
17314                         DrawType DrawType
17315
17316                         Mesh  string
17317                         Scale float32
17318                         //mt:const uint8(6)
17319                         Tiles        [6]TileDef
17320                         OverlayTiles [6]TileDef
17321                         //mt:const uint8(6)
17322                         SpecialTiles [6]TileDef
17323
17324                         Color   color.NRGBA
17325                         Palette Texture
17326
17327                         Waving       WaveType
17328                         ConnectSides uint8
17329                         ConnectTo    []Content
17330                         InsideTint   color.NRGBA
17331                         Level        uint8 // Must be < 128.
17332
17333                         Translucent bool // Sunlight is scattered and becomes normal light.
17334                         Transparent bool // Sunlight isn't scattered.
17335                         LightSrc    uint8
17336
17337                         GndContent   bool
17338                         Collides     bool
17339                         Pointable    bool
17340                         Diggable     bool
17341                         Climbable    bool
17342                         Replaceable  bool
17343                         OnRightClick bool
17344
17345                         DmgPerSec int32
17346
17347                         LiquidType   LiquidType
17348                         FlowingAlt   string
17349                         SrcAlt       string
17350                         Viscosity    uint8 // 0-7
17351                         LiqRenewable bool
17352                         FlowRange    uint8
17353                         DrownDmg     uint8
17354                         Floodable    bool
17355
17356                         DrawBox, ColBox, SelBox NodeBox
17357
17358                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17359
17360                         LegacyFaceDir bool
17361                         LegacyMounted bool
17362
17363                         DigPredict string
17364
17365                         MaxLvl uint8
17366
17367                         AlphaUse
17368                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17369                         chk(ErrTooLong)
17370                 }
17371                 {
17372                         x := uint16(len(([]byte((*(*(struct {
17373                                 Param0 Content
17374
17375                                 Name   string
17376                                 Groups []Group
17377
17378                                 P1Type   Param1Type
17379                                 P2Type   Param2Type
17380                                 DrawType DrawType
17381
17382                                 Mesh  string
17383                                 Scale float32
17384                                 //mt:const uint8(6)
17385                                 Tiles        [6]TileDef
17386                                 OverlayTiles [6]TileDef
17387                                 //mt:const uint8(6)
17388                                 SpecialTiles [6]TileDef
17389
17390                                 Color   color.NRGBA
17391                                 Palette Texture
17392
17393                                 Waving       WaveType
17394                                 ConnectSides uint8
17395                                 ConnectTo    []Content
17396                                 InsideTint   color.NRGBA
17397                                 Level        uint8 // Must be < 128.
17398
17399                                 Translucent bool // Sunlight is scattered and becomes normal light.
17400                                 Transparent bool // Sunlight isn't scattered.
17401                                 LightSrc    uint8
17402
17403                                 GndContent   bool
17404                                 Collides     bool
17405                                 Pointable    bool
17406                                 Diggable     bool
17407                                 Climbable    bool
17408                                 Replaceable  bool
17409                                 OnRightClick bool
17410
17411                                 DmgPerSec int32
17412
17413                                 LiquidType   LiquidType
17414                                 FlowingAlt   string
17415                                 SrcAlt       string
17416                                 Viscosity    uint8 // 0-7
17417                                 LiqRenewable bool
17418                                 FlowRange    uint8
17419                                 DrownDmg     uint8
17420                                 Floodable    bool
17421
17422                                 DrawBox, ColBox, SelBox NodeBox
17423
17424                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17425
17426                                 LegacyFaceDir bool
17427                                 LegacyMounted bool
17428
17429                                 DigPredict string
17430
17431                                 MaxLvl uint8
17432
17433                                 AlphaUse
17434                         }))(obj)).SrcAlt))))
17435                         write16(w, uint16(x))
17436                 }
17437                 {
17438                         _, err := w.Write(([]byte((*(*(struct {
17439                                 Param0 Content
17440
17441                                 Name   string
17442                                 Groups []Group
17443
17444                                 P1Type   Param1Type
17445                                 P2Type   Param2Type
17446                                 DrawType DrawType
17447
17448                                 Mesh  string
17449                                 Scale float32
17450                                 //mt:const uint8(6)
17451                                 Tiles        [6]TileDef
17452                                 OverlayTiles [6]TileDef
17453                                 //mt:const uint8(6)
17454                                 SpecialTiles [6]TileDef
17455
17456                                 Color   color.NRGBA
17457                                 Palette Texture
17458
17459                                 Waving       WaveType
17460                                 ConnectSides uint8
17461                                 ConnectTo    []Content
17462                                 InsideTint   color.NRGBA
17463                                 Level        uint8 // Must be < 128.
17464
17465                                 Translucent bool // Sunlight is scattered and becomes normal light.
17466                                 Transparent bool // Sunlight isn't scattered.
17467                                 LightSrc    uint8
17468
17469                                 GndContent   bool
17470                                 Collides     bool
17471                                 Pointable    bool
17472                                 Diggable     bool
17473                                 Climbable    bool
17474                                 Replaceable  bool
17475                                 OnRightClick bool
17476
17477                                 DmgPerSec int32
17478
17479                                 LiquidType   LiquidType
17480                                 FlowingAlt   string
17481                                 SrcAlt       string
17482                                 Viscosity    uint8 // 0-7
17483                                 LiqRenewable bool
17484                                 FlowRange    uint8
17485                                 DrownDmg     uint8
17486                                 Floodable    bool
17487
17488                                 DrawBox, ColBox, SelBox NodeBox
17489
17490                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17491
17492                                 LegacyFaceDir bool
17493                                 LegacyMounted bool
17494
17495                                 DigPredict string
17496
17497                                 MaxLvl uint8
17498
17499                                 AlphaUse
17500                         }))(obj)).SrcAlt))[:])
17501                         chk(err)
17502                 }
17503                 {
17504                         x := (*(*(struct {
17505                                 Param0 Content
17506
17507                                 Name   string
17508                                 Groups []Group
17509
17510                                 P1Type   Param1Type
17511                                 P2Type   Param2Type
17512                                 DrawType DrawType
17513
17514                                 Mesh  string
17515                                 Scale float32
17516                                 //mt:const uint8(6)
17517                                 Tiles        [6]TileDef
17518                                 OverlayTiles [6]TileDef
17519                                 //mt:const uint8(6)
17520                                 SpecialTiles [6]TileDef
17521
17522                                 Color   color.NRGBA
17523                                 Palette Texture
17524
17525                                 Waving       WaveType
17526                                 ConnectSides uint8
17527                                 ConnectTo    []Content
17528                                 InsideTint   color.NRGBA
17529                                 Level        uint8 // Must be < 128.
17530
17531                                 Translucent bool // Sunlight is scattered and becomes normal light.
17532                                 Transparent bool // Sunlight isn't scattered.
17533                                 LightSrc    uint8
17534
17535                                 GndContent   bool
17536                                 Collides     bool
17537                                 Pointable    bool
17538                                 Diggable     bool
17539                                 Climbable    bool
17540                                 Replaceable  bool
17541                                 OnRightClick bool
17542
17543                                 DmgPerSec int32
17544
17545                                 LiquidType   LiquidType
17546                                 FlowingAlt   string
17547                                 SrcAlt       string
17548                                 Viscosity    uint8 // 0-7
17549                                 LiqRenewable bool
17550                                 FlowRange    uint8
17551                                 DrownDmg     uint8
17552                                 Floodable    bool
17553
17554                                 DrawBox, ColBox, SelBox NodeBox
17555
17556                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17557
17558                                 LegacyFaceDir bool
17559                                 LegacyMounted bool
17560
17561                                 DigPredict string
17562
17563                                 MaxLvl uint8
17564
17565                                 AlphaUse
17566                         }))(obj)).Viscosity
17567                         write8(w, uint8(x))
17568                 }
17569                 {
17570                         x := (*(*(struct {
17571                                 Param0 Content
17572
17573                                 Name   string
17574                                 Groups []Group
17575
17576                                 P1Type   Param1Type
17577                                 P2Type   Param2Type
17578                                 DrawType DrawType
17579
17580                                 Mesh  string
17581                                 Scale float32
17582                                 //mt:const uint8(6)
17583                                 Tiles        [6]TileDef
17584                                 OverlayTiles [6]TileDef
17585                                 //mt:const uint8(6)
17586                                 SpecialTiles [6]TileDef
17587
17588                                 Color   color.NRGBA
17589                                 Palette Texture
17590
17591                                 Waving       WaveType
17592                                 ConnectSides uint8
17593                                 ConnectTo    []Content
17594                                 InsideTint   color.NRGBA
17595                                 Level        uint8 // Must be < 128.
17596
17597                                 Translucent bool // Sunlight is scattered and becomes normal light.
17598                                 Transparent bool // Sunlight isn't scattered.
17599                                 LightSrc    uint8
17600
17601                                 GndContent   bool
17602                                 Collides     bool
17603                                 Pointable    bool
17604                                 Diggable     bool
17605                                 Climbable    bool
17606                                 Replaceable  bool
17607                                 OnRightClick bool
17608
17609                                 DmgPerSec int32
17610
17611                                 LiquidType   LiquidType
17612                                 FlowingAlt   string
17613                                 SrcAlt       string
17614                                 Viscosity    uint8 // 0-7
17615                                 LiqRenewable bool
17616                                 FlowRange    uint8
17617                                 DrownDmg     uint8
17618                                 Floodable    bool
17619
17620                                 DrawBox, ColBox, SelBox NodeBox
17621
17622                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17623
17624                                 LegacyFaceDir bool
17625                                 LegacyMounted bool
17626
17627                                 DigPredict string
17628
17629                                 MaxLvl uint8
17630
17631                                 AlphaUse
17632                         }))(obj)).LiqRenewable
17633                         if x {
17634                                 write8(w, 1)
17635                         } else {
17636                                 write8(w, 0)
17637                         }
17638                 }
17639                 {
17640                         x := (*(*(struct {
17641                                 Param0 Content
17642
17643                                 Name   string
17644                                 Groups []Group
17645
17646                                 P1Type   Param1Type
17647                                 P2Type   Param2Type
17648                                 DrawType DrawType
17649
17650                                 Mesh  string
17651                                 Scale float32
17652                                 //mt:const uint8(6)
17653                                 Tiles        [6]TileDef
17654                                 OverlayTiles [6]TileDef
17655                                 //mt:const uint8(6)
17656                                 SpecialTiles [6]TileDef
17657
17658                                 Color   color.NRGBA
17659                                 Palette Texture
17660
17661                                 Waving       WaveType
17662                                 ConnectSides uint8
17663                                 ConnectTo    []Content
17664                                 InsideTint   color.NRGBA
17665                                 Level        uint8 // Must be < 128.
17666
17667                                 Translucent bool // Sunlight is scattered and becomes normal light.
17668                                 Transparent bool // Sunlight isn't scattered.
17669                                 LightSrc    uint8
17670
17671                                 GndContent   bool
17672                                 Collides     bool
17673                                 Pointable    bool
17674                                 Diggable     bool
17675                                 Climbable    bool
17676                                 Replaceable  bool
17677                                 OnRightClick bool
17678
17679                                 DmgPerSec int32
17680
17681                                 LiquidType   LiquidType
17682                                 FlowingAlt   string
17683                                 SrcAlt       string
17684                                 Viscosity    uint8 // 0-7
17685                                 LiqRenewable bool
17686                                 FlowRange    uint8
17687                                 DrownDmg     uint8
17688                                 Floodable    bool
17689
17690                                 DrawBox, ColBox, SelBox NodeBox
17691
17692                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17693
17694                                 LegacyFaceDir bool
17695                                 LegacyMounted bool
17696
17697                                 DigPredict string
17698
17699                                 MaxLvl uint8
17700
17701                                 AlphaUse
17702                         }))(obj)).FlowRange
17703                         write8(w, uint8(x))
17704                 }
17705                 {
17706                         x := (*(*(struct {
17707                                 Param0 Content
17708
17709                                 Name   string
17710                                 Groups []Group
17711
17712                                 P1Type   Param1Type
17713                                 P2Type   Param2Type
17714                                 DrawType DrawType
17715
17716                                 Mesh  string
17717                                 Scale float32
17718                                 //mt:const uint8(6)
17719                                 Tiles        [6]TileDef
17720                                 OverlayTiles [6]TileDef
17721                                 //mt:const uint8(6)
17722                                 SpecialTiles [6]TileDef
17723
17724                                 Color   color.NRGBA
17725                                 Palette Texture
17726
17727                                 Waving       WaveType
17728                                 ConnectSides uint8
17729                                 ConnectTo    []Content
17730                                 InsideTint   color.NRGBA
17731                                 Level        uint8 // Must be < 128.
17732
17733                                 Translucent bool // Sunlight is scattered and becomes normal light.
17734                                 Transparent bool // Sunlight isn't scattered.
17735                                 LightSrc    uint8
17736
17737                                 GndContent   bool
17738                                 Collides     bool
17739                                 Pointable    bool
17740                                 Diggable     bool
17741                                 Climbable    bool
17742                                 Replaceable  bool
17743                                 OnRightClick bool
17744
17745                                 DmgPerSec int32
17746
17747                                 LiquidType   LiquidType
17748                                 FlowingAlt   string
17749                                 SrcAlt       string
17750                                 Viscosity    uint8 // 0-7
17751                                 LiqRenewable bool
17752                                 FlowRange    uint8
17753                                 DrownDmg     uint8
17754                                 Floodable    bool
17755
17756                                 DrawBox, ColBox, SelBox NodeBox
17757
17758                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17759
17760                                 LegacyFaceDir bool
17761                                 LegacyMounted bool
17762
17763                                 DigPredict string
17764
17765                                 MaxLvl uint8
17766
17767                                 AlphaUse
17768                         }))(obj)).DrownDmg
17769                         write8(w, uint8(x))
17770                 }
17771                 {
17772                         x := (*(*(struct {
17773                                 Param0 Content
17774
17775                                 Name   string
17776                                 Groups []Group
17777
17778                                 P1Type   Param1Type
17779                                 P2Type   Param2Type
17780                                 DrawType DrawType
17781
17782                                 Mesh  string
17783                                 Scale float32
17784                                 //mt:const uint8(6)
17785                                 Tiles        [6]TileDef
17786                                 OverlayTiles [6]TileDef
17787                                 //mt:const uint8(6)
17788                                 SpecialTiles [6]TileDef
17789
17790                                 Color   color.NRGBA
17791                                 Palette Texture
17792
17793                                 Waving       WaveType
17794                                 ConnectSides uint8
17795                                 ConnectTo    []Content
17796                                 InsideTint   color.NRGBA
17797                                 Level        uint8 // Must be < 128.
17798
17799                                 Translucent bool // Sunlight is scattered and becomes normal light.
17800                                 Transparent bool // Sunlight isn't scattered.
17801                                 LightSrc    uint8
17802
17803                                 GndContent   bool
17804                                 Collides     bool
17805                                 Pointable    bool
17806                                 Diggable     bool
17807                                 Climbable    bool
17808                                 Replaceable  bool
17809                                 OnRightClick bool
17810
17811                                 DmgPerSec int32
17812
17813                                 LiquidType   LiquidType
17814                                 FlowingAlt   string
17815                                 SrcAlt       string
17816                                 Viscosity    uint8 // 0-7
17817                                 LiqRenewable bool
17818                                 FlowRange    uint8
17819                                 DrownDmg     uint8
17820                                 Floodable    bool
17821
17822                                 DrawBox, ColBox, SelBox NodeBox
17823
17824                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17825
17826                                 LegacyFaceDir bool
17827                                 LegacyMounted bool
17828
17829                                 DigPredict string
17830
17831                                 MaxLvl uint8
17832
17833                                 AlphaUse
17834                         }))(obj)).Floodable
17835                         if x {
17836                                 write8(w, 1)
17837                         } else {
17838                                 write8(w, 0)
17839                         }
17840                 }
17841                 if err := pcall(func() {
17842                         ((*(*(struct {
17843                                 Param0 Content
17844
17845                                 Name   string
17846                                 Groups []Group
17847
17848                                 P1Type   Param1Type
17849                                 P2Type   Param2Type
17850                                 DrawType DrawType
17851
17852                                 Mesh  string
17853                                 Scale float32
17854                                 //mt:const uint8(6)
17855                                 Tiles        [6]TileDef
17856                                 OverlayTiles [6]TileDef
17857                                 //mt:const uint8(6)
17858                                 SpecialTiles [6]TileDef
17859
17860                                 Color   color.NRGBA
17861                                 Palette Texture
17862
17863                                 Waving       WaveType
17864                                 ConnectSides uint8
17865                                 ConnectTo    []Content
17866                                 InsideTint   color.NRGBA
17867                                 Level        uint8 // Must be < 128.
17868
17869                                 Translucent bool // Sunlight is scattered and becomes normal light.
17870                                 Transparent bool // Sunlight isn't scattered.
17871                                 LightSrc    uint8
17872
17873                                 GndContent   bool
17874                                 Collides     bool
17875                                 Pointable    bool
17876                                 Diggable     bool
17877                                 Climbable    bool
17878                                 Replaceable  bool
17879                                 OnRightClick bool
17880
17881                                 DmgPerSec int32
17882
17883                                 LiquidType   LiquidType
17884                                 FlowingAlt   string
17885                                 SrcAlt       string
17886                                 Viscosity    uint8 // 0-7
17887                                 LiqRenewable bool
17888                                 FlowRange    uint8
17889                                 DrownDmg     uint8
17890                                 Floodable    bool
17891
17892                                 DrawBox, ColBox, SelBox NodeBox
17893
17894                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17895
17896                                 LegacyFaceDir bool
17897                                 LegacyMounted bool
17898
17899                                 DigPredict string
17900
17901                                 MaxLvl uint8
17902
17903                                 AlphaUse
17904                         }))(obj)).DrawBox).serialize(w)
17905                 }); err != nil {
17906                         if err == io.EOF {
17907                                 chk(io.EOF)
17908                         }
17909                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
17910                 }
17911                 if err := pcall(func() {
17912                         ((*(*(struct {
17913                                 Param0 Content
17914
17915                                 Name   string
17916                                 Groups []Group
17917
17918                                 P1Type   Param1Type
17919                                 P2Type   Param2Type
17920                                 DrawType DrawType
17921
17922                                 Mesh  string
17923                                 Scale float32
17924                                 //mt:const uint8(6)
17925                                 Tiles        [6]TileDef
17926                                 OverlayTiles [6]TileDef
17927                                 //mt:const uint8(6)
17928                                 SpecialTiles [6]TileDef
17929
17930                                 Color   color.NRGBA
17931                                 Palette Texture
17932
17933                                 Waving       WaveType
17934                                 ConnectSides uint8
17935                                 ConnectTo    []Content
17936                                 InsideTint   color.NRGBA
17937                                 Level        uint8 // Must be < 128.
17938
17939                                 Translucent bool // Sunlight is scattered and becomes normal light.
17940                                 Transparent bool // Sunlight isn't scattered.
17941                                 LightSrc    uint8
17942
17943                                 GndContent   bool
17944                                 Collides     bool
17945                                 Pointable    bool
17946                                 Diggable     bool
17947                                 Climbable    bool
17948                                 Replaceable  bool
17949                                 OnRightClick bool
17950
17951                                 DmgPerSec int32
17952
17953                                 LiquidType   LiquidType
17954                                 FlowingAlt   string
17955                                 SrcAlt       string
17956                                 Viscosity    uint8 // 0-7
17957                                 LiqRenewable bool
17958                                 FlowRange    uint8
17959                                 DrownDmg     uint8
17960                                 Floodable    bool
17961
17962                                 DrawBox, ColBox, SelBox NodeBox
17963
17964                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17965
17966                                 LegacyFaceDir bool
17967                                 LegacyMounted bool
17968
17969                                 DigPredict string
17970
17971                                 MaxLvl uint8
17972
17973                                 AlphaUse
17974                         }))(obj)).ColBox).serialize(w)
17975                 }); err != nil {
17976                         if err == io.EOF {
17977                                 chk(io.EOF)
17978                         }
17979                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
17980                 }
17981                 if err := pcall(func() {
17982                         ((*(*(struct {
17983                                 Param0 Content
17984
17985                                 Name   string
17986                                 Groups []Group
17987
17988                                 P1Type   Param1Type
17989                                 P2Type   Param2Type
17990                                 DrawType DrawType
17991
17992                                 Mesh  string
17993                                 Scale float32
17994                                 //mt:const uint8(6)
17995                                 Tiles        [6]TileDef
17996                                 OverlayTiles [6]TileDef
17997                                 //mt:const uint8(6)
17998                                 SpecialTiles [6]TileDef
17999
18000                                 Color   color.NRGBA
18001                                 Palette Texture
18002
18003                                 Waving       WaveType
18004                                 ConnectSides uint8
18005                                 ConnectTo    []Content
18006                                 InsideTint   color.NRGBA
18007                                 Level        uint8 // Must be < 128.
18008
18009                                 Translucent bool // Sunlight is scattered and becomes normal light.
18010                                 Transparent bool // Sunlight isn't scattered.
18011                                 LightSrc    uint8
18012
18013                                 GndContent   bool
18014                                 Collides     bool
18015                                 Pointable    bool
18016                                 Diggable     bool
18017                                 Climbable    bool
18018                                 Replaceable  bool
18019                                 OnRightClick bool
18020
18021                                 DmgPerSec int32
18022
18023                                 LiquidType   LiquidType
18024                                 FlowingAlt   string
18025                                 SrcAlt       string
18026                                 Viscosity    uint8 // 0-7
18027                                 LiqRenewable bool
18028                                 FlowRange    uint8
18029                                 DrownDmg     uint8
18030                                 Floodable    bool
18031
18032                                 DrawBox, ColBox, SelBox NodeBox
18033
18034                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18035
18036                                 LegacyFaceDir bool
18037                                 LegacyMounted bool
18038
18039                                 DigPredict string
18040
18041                                 MaxLvl uint8
18042
18043                                 AlphaUse
18044                         }))(obj)).SelBox).serialize(w)
18045                 }); err != nil {
18046                         if err == io.EOF {
18047                                 chk(io.EOF)
18048                         }
18049                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18050                 }
18051                 if err := pcall(func() {
18052                         ((*(*(struct {
18053                                 Param0 Content
18054
18055                                 Name   string
18056                                 Groups []Group
18057
18058                                 P1Type   Param1Type
18059                                 P2Type   Param2Type
18060                                 DrawType DrawType
18061
18062                                 Mesh  string
18063                                 Scale float32
18064                                 //mt:const uint8(6)
18065                                 Tiles        [6]TileDef
18066                                 OverlayTiles [6]TileDef
18067                                 //mt:const uint8(6)
18068                                 SpecialTiles [6]TileDef
18069
18070                                 Color   color.NRGBA
18071                                 Palette Texture
18072
18073                                 Waving       WaveType
18074                                 ConnectSides uint8
18075                                 ConnectTo    []Content
18076                                 InsideTint   color.NRGBA
18077                                 Level        uint8 // Must be < 128.
18078
18079                                 Translucent bool // Sunlight is scattered and becomes normal light.
18080                                 Transparent bool // Sunlight isn't scattered.
18081                                 LightSrc    uint8
18082
18083                                 GndContent   bool
18084                                 Collides     bool
18085                                 Pointable    bool
18086                                 Diggable     bool
18087                                 Climbable    bool
18088                                 Replaceable  bool
18089                                 OnRightClick bool
18090
18091                                 DmgPerSec int32
18092
18093                                 LiquidType   LiquidType
18094                                 FlowingAlt   string
18095                                 SrcAlt       string
18096                                 Viscosity    uint8 // 0-7
18097                                 LiqRenewable bool
18098                                 FlowRange    uint8
18099                                 DrownDmg     uint8
18100                                 Floodable    bool
18101
18102                                 DrawBox, ColBox, SelBox NodeBox
18103
18104                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18105
18106                                 LegacyFaceDir bool
18107                                 LegacyMounted bool
18108
18109                                 DigPredict string
18110
18111                                 MaxLvl uint8
18112
18113                                 AlphaUse
18114                         }))(obj)).FootstepSnd).serialize(w)
18115                 }); err != nil {
18116                         if err == io.EOF {
18117                                 chk(io.EOF)
18118                         }
18119                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18120                 }
18121                 if err := pcall(func() {
18122                         ((*(*(struct {
18123                                 Param0 Content
18124
18125                                 Name   string
18126                                 Groups []Group
18127
18128                                 P1Type   Param1Type
18129                                 P2Type   Param2Type
18130                                 DrawType DrawType
18131
18132                                 Mesh  string
18133                                 Scale float32
18134                                 //mt:const uint8(6)
18135                                 Tiles        [6]TileDef
18136                                 OverlayTiles [6]TileDef
18137                                 //mt:const uint8(6)
18138                                 SpecialTiles [6]TileDef
18139
18140                                 Color   color.NRGBA
18141                                 Palette Texture
18142
18143                                 Waving       WaveType
18144                                 ConnectSides uint8
18145                                 ConnectTo    []Content
18146                                 InsideTint   color.NRGBA
18147                                 Level        uint8 // Must be < 128.
18148
18149                                 Translucent bool // Sunlight is scattered and becomes normal light.
18150                                 Transparent bool // Sunlight isn't scattered.
18151                                 LightSrc    uint8
18152
18153                                 GndContent   bool
18154                                 Collides     bool
18155                                 Pointable    bool
18156                                 Diggable     bool
18157                                 Climbable    bool
18158                                 Replaceable  bool
18159                                 OnRightClick bool
18160
18161                                 DmgPerSec int32
18162
18163                                 LiquidType   LiquidType
18164                                 FlowingAlt   string
18165                                 SrcAlt       string
18166                                 Viscosity    uint8 // 0-7
18167                                 LiqRenewable bool
18168                                 FlowRange    uint8
18169                                 DrownDmg     uint8
18170                                 Floodable    bool
18171
18172                                 DrawBox, ColBox, SelBox NodeBox
18173
18174                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18175
18176                                 LegacyFaceDir bool
18177                                 LegacyMounted bool
18178
18179                                 DigPredict string
18180
18181                                 MaxLvl uint8
18182
18183                                 AlphaUse
18184                         }))(obj)).DiggingSnd).serialize(w)
18185                 }); err != nil {
18186                         if err == io.EOF {
18187                                 chk(io.EOF)
18188                         }
18189                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18190                 }
18191                 if err := pcall(func() {
18192                         ((*(*(struct {
18193                                 Param0 Content
18194
18195                                 Name   string
18196                                 Groups []Group
18197
18198                                 P1Type   Param1Type
18199                                 P2Type   Param2Type
18200                                 DrawType DrawType
18201
18202                                 Mesh  string
18203                                 Scale float32
18204                                 //mt:const uint8(6)
18205                                 Tiles        [6]TileDef
18206                                 OverlayTiles [6]TileDef
18207                                 //mt:const uint8(6)
18208                                 SpecialTiles [6]TileDef
18209
18210                                 Color   color.NRGBA
18211                                 Palette Texture
18212
18213                                 Waving       WaveType
18214                                 ConnectSides uint8
18215                                 ConnectTo    []Content
18216                                 InsideTint   color.NRGBA
18217                                 Level        uint8 // Must be < 128.
18218
18219                                 Translucent bool // Sunlight is scattered and becomes normal light.
18220                                 Transparent bool // Sunlight isn't scattered.
18221                                 LightSrc    uint8
18222
18223                                 GndContent   bool
18224                                 Collides     bool
18225                                 Pointable    bool
18226                                 Diggable     bool
18227                                 Climbable    bool
18228                                 Replaceable  bool
18229                                 OnRightClick bool
18230
18231                                 DmgPerSec int32
18232
18233                                 LiquidType   LiquidType
18234                                 FlowingAlt   string
18235                                 SrcAlt       string
18236                                 Viscosity    uint8 // 0-7
18237                                 LiqRenewable bool
18238                                 FlowRange    uint8
18239                                 DrownDmg     uint8
18240                                 Floodable    bool
18241
18242                                 DrawBox, ColBox, SelBox NodeBox
18243
18244                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18245
18246                                 LegacyFaceDir bool
18247                                 LegacyMounted bool
18248
18249                                 DigPredict string
18250
18251                                 MaxLvl uint8
18252
18253                                 AlphaUse
18254                         }))(obj)).DugSnd).serialize(w)
18255                 }); err != nil {
18256                         if err == io.EOF {
18257                                 chk(io.EOF)
18258                         }
18259                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18260                 }
18261                 {
18262                         x := (*(*(struct {
18263                                 Param0 Content
18264
18265                                 Name   string
18266                                 Groups []Group
18267
18268                                 P1Type   Param1Type
18269                                 P2Type   Param2Type
18270                                 DrawType DrawType
18271
18272                                 Mesh  string
18273                                 Scale float32
18274                                 //mt:const uint8(6)
18275                                 Tiles        [6]TileDef
18276                                 OverlayTiles [6]TileDef
18277                                 //mt:const uint8(6)
18278                                 SpecialTiles [6]TileDef
18279
18280                                 Color   color.NRGBA
18281                                 Palette Texture
18282
18283                                 Waving       WaveType
18284                                 ConnectSides uint8
18285                                 ConnectTo    []Content
18286                                 InsideTint   color.NRGBA
18287                                 Level        uint8 // Must be < 128.
18288
18289                                 Translucent bool // Sunlight is scattered and becomes normal light.
18290                                 Transparent bool // Sunlight isn't scattered.
18291                                 LightSrc    uint8
18292
18293                                 GndContent   bool
18294                                 Collides     bool
18295                                 Pointable    bool
18296                                 Diggable     bool
18297                                 Climbable    bool
18298                                 Replaceable  bool
18299                                 OnRightClick bool
18300
18301                                 DmgPerSec int32
18302
18303                                 LiquidType   LiquidType
18304                                 FlowingAlt   string
18305                                 SrcAlt       string
18306                                 Viscosity    uint8 // 0-7
18307                                 LiqRenewable bool
18308                                 FlowRange    uint8
18309                                 DrownDmg     uint8
18310                                 Floodable    bool
18311
18312                                 DrawBox, ColBox, SelBox NodeBox
18313
18314                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18315
18316                                 LegacyFaceDir bool
18317                                 LegacyMounted bool
18318
18319                                 DigPredict string
18320
18321                                 MaxLvl uint8
18322
18323                                 AlphaUse
18324                         }))(obj)).LegacyFaceDir
18325                         if x {
18326                                 write8(w, 1)
18327                         } else {
18328                                 write8(w, 0)
18329                         }
18330                 }
18331                 {
18332                         x := (*(*(struct {
18333                                 Param0 Content
18334
18335                                 Name   string
18336                                 Groups []Group
18337
18338                                 P1Type   Param1Type
18339                                 P2Type   Param2Type
18340                                 DrawType DrawType
18341
18342                                 Mesh  string
18343                                 Scale float32
18344                                 //mt:const uint8(6)
18345                                 Tiles        [6]TileDef
18346                                 OverlayTiles [6]TileDef
18347                                 //mt:const uint8(6)
18348                                 SpecialTiles [6]TileDef
18349
18350                                 Color   color.NRGBA
18351                                 Palette Texture
18352
18353                                 Waving       WaveType
18354                                 ConnectSides uint8
18355                                 ConnectTo    []Content
18356                                 InsideTint   color.NRGBA
18357                                 Level        uint8 // Must be < 128.
18358
18359                                 Translucent bool // Sunlight is scattered and becomes normal light.
18360                                 Transparent bool // Sunlight isn't scattered.
18361                                 LightSrc    uint8
18362
18363                                 GndContent   bool
18364                                 Collides     bool
18365                                 Pointable    bool
18366                                 Diggable     bool
18367                                 Climbable    bool
18368                                 Replaceable  bool
18369                                 OnRightClick bool
18370
18371                                 DmgPerSec int32
18372
18373                                 LiquidType   LiquidType
18374                                 FlowingAlt   string
18375                                 SrcAlt       string
18376                                 Viscosity    uint8 // 0-7
18377                                 LiqRenewable bool
18378                                 FlowRange    uint8
18379                                 DrownDmg     uint8
18380                                 Floodable    bool
18381
18382                                 DrawBox, ColBox, SelBox NodeBox
18383
18384                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18385
18386                                 LegacyFaceDir bool
18387                                 LegacyMounted bool
18388
18389                                 DigPredict string
18390
18391                                 MaxLvl uint8
18392
18393                                 AlphaUse
18394                         }))(obj)).LegacyMounted
18395                         if x {
18396                                 write8(w, 1)
18397                         } else {
18398                                 write8(w, 0)
18399                         }
18400                 }
18401                 if len(([]byte((*(*(struct {
18402                         Param0 Content
18403
18404                         Name   string
18405                         Groups []Group
18406
18407                         P1Type   Param1Type
18408                         P2Type   Param2Type
18409                         DrawType DrawType
18410
18411                         Mesh  string
18412                         Scale float32
18413                         //mt:const uint8(6)
18414                         Tiles        [6]TileDef
18415                         OverlayTiles [6]TileDef
18416                         //mt:const uint8(6)
18417                         SpecialTiles [6]TileDef
18418
18419                         Color   color.NRGBA
18420                         Palette Texture
18421
18422                         Waving       WaveType
18423                         ConnectSides uint8
18424                         ConnectTo    []Content
18425                         InsideTint   color.NRGBA
18426                         Level        uint8 // Must be < 128.
18427
18428                         Translucent bool // Sunlight is scattered and becomes normal light.
18429                         Transparent bool // Sunlight isn't scattered.
18430                         LightSrc    uint8
18431
18432                         GndContent   bool
18433                         Collides     bool
18434                         Pointable    bool
18435                         Diggable     bool
18436                         Climbable    bool
18437                         Replaceable  bool
18438                         OnRightClick bool
18439
18440                         DmgPerSec int32
18441
18442                         LiquidType   LiquidType
18443                         FlowingAlt   string
18444                         SrcAlt       string
18445                         Viscosity    uint8 // 0-7
18446                         LiqRenewable bool
18447                         FlowRange    uint8
18448                         DrownDmg     uint8
18449                         Floodable    bool
18450
18451                         DrawBox, ColBox, SelBox NodeBox
18452
18453                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18454
18455                         LegacyFaceDir bool
18456                         LegacyMounted bool
18457
18458                         DigPredict string
18459
18460                         MaxLvl uint8
18461
18462                         AlphaUse
18463                 }))(obj)).DigPredict))) > math.MaxUint16 {
18464                         chk(ErrTooLong)
18465                 }
18466                 {
18467                         x := uint16(len(([]byte((*(*(struct {
18468                                 Param0 Content
18469
18470                                 Name   string
18471                                 Groups []Group
18472
18473                                 P1Type   Param1Type
18474                                 P2Type   Param2Type
18475                                 DrawType DrawType
18476
18477                                 Mesh  string
18478                                 Scale float32
18479                                 //mt:const uint8(6)
18480                                 Tiles        [6]TileDef
18481                                 OverlayTiles [6]TileDef
18482                                 //mt:const uint8(6)
18483                                 SpecialTiles [6]TileDef
18484
18485                                 Color   color.NRGBA
18486                                 Palette Texture
18487
18488                                 Waving       WaveType
18489                                 ConnectSides uint8
18490                                 ConnectTo    []Content
18491                                 InsideTint   color.NRGBA
18492                                 Level        uint8 // Must be < 128.
18493
18494                                 Translucent bool // Sunlight is scattered and becomes normal light.
18495                                 Transparent bool // Sunlight isn't scattered.
18496                                 LightSrc    uint8
18497
18498                                 GndContent   bool
18499                                 Collides     bool
18500                                 Pointable    bool
18501                                 Diggable     bool
18502                                 Climbable    bool
18503                                 Replaceable  bool
18504                                 OnRightClick bool
18505
18506                                 DmgPerSec int32
18507
18508                                 LiquidType   LiquidType
18509                                 FlowingAlt   string
18510                                 SrcAlt       string
18511                                 Viscosity    uint8 // 0-7
18512                                 LiqRenewable bool
18513                                 FlowRange    uint8
18514                                 DrownDmg     uint8
18515                                 Floodable    bool
18516
18517                                 DrawBox, ColBox, SelBox NodeBox
18518
18519                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18520
18521                                 LegacyFaceDir bool
18522                                 LegacyMounted bool
18523
18524                                 DigPredict string
18525
18526                                 MaxLvl uint8
18527
18528                                 AlphaUse
18529                         }))(obj)).DigPredict))))
18530                         write16(w, uint16(x))
18531                 }
18532                 {
18533                         _, err := w.Write(([]byte((*(*(struct {
18534                                 Param0 Content
18535
18536                                 Name   string
18537                                 Groups []Group
18538
18539                                 P1Type   Param1Type
18540                                 P2Type   Param2Type
18541                                 DrawType DrawType
18542
18543                                 Mesh  string
18544                                 Scale float32
18545                                 //mt:const uint8(6)
18546                                 Tiles        [6]TileDef
18547                                 OverlayTiles [6]TileDef
18548                                 //mt:const uint8(6)
18549                                 SpecialTiles [6]TileDef
18550
18551                                 Color   color.NRGBA
18552                                 Palette Texture
18553
18554                                 Waving       WaveType
18555                                 ConnectSides uint8
18556                                 ConnectTo    []Content
18557                                 InsideTint   color.NRGBA
18558                                 Level        uint8 // Must be < 128.
18559
18560                                 Translucent bool // Sunlight is scattered and becomes normal light.
18561                                 Transparent bool // Sunlight isn't scattered.
18562                                 LightSrc    uint8
18563
18564                                 GndContent   bool
18565                                 Collides     bool
18566                                 Pointable    bool
18567                                 Diggable     bool
18568                                 Climbable    bool
18569                                 Replaceable  bool
18570                                 OnRightClick bool
18571
18572                                 DmgPerSec int32
18573
18574                                 LiquidType   LiquidType
18575                                 FlowingAlt   string
18576                                 SrcAlt       string
18577                                 Viscosity    uint8 // 0-7
18578                                 LiqRenewable bool
18579                                 FlowRange    uint8
18580                                 DrownDmg     uint8
18581                                 Floodable    bool
18582
18583                                 DrawBox, ColBox, SelBox NodeBox
18584
18585                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18586
18587                                 LegacyFaceDir bool
18588                                 LegacyMounted bool
18589
18590                                 DigPredict string
18591
18592                                 MaxLvl uint8
18593
18594                                 AlphaUse
18595                         }))(obj)).DigPredict))[:])
18596                         chk(err)
18597                 }
18598                 {
18599                         x := (*(*(struct {
18600                                 Param0 Content
18601
18602                                 Name   string
18603                                 Groups []Group
18604
18605                                 P1Type   Param1Type
18606                                 P2Type   Param2Type
18607                                 DrawType DrawType
18608
18609                                 Mesh  string
18610                                 Scale float32
18611                                 //mt:const uint8(6)
18612                                 Tiles        [6]TileDef
18613                                 OverlayTiles [6]TileDef
18614                                 //mt:const uint8(6)
18615                                 SpecialTiles [6]TileDef
18616
18617                                 Color   color.NRGBA
18618                                 Palette Texture
18619
18620                                 Waving       WaveType
18621                                 ConnectSides uint8
18622                                 ConnectTo    []Content
18623                                 InsideTint   color.NRGBA
18624                                 Level        uint8 // Must be < 128.
18625
18626                                 Translucent bool // Sunlight is scattered and becomes normal light.
18627                                 Transparent bool // Sunlight isn't scattered.
18628                                 LightSrc    uint8
18629
18630                                 GndContent   bool
18631                                 Collides     bool
18632                                 Pointable    bool
18633                                 Diggable     bool
18634                                 Climbable    bool
18635                                 Replaceable  bool
18636                                 OnRightClick bool
18637
18638                                 DmgPerSec int32
18639
18640                                 LiquidType   LiquidType
18641                                 FlowingAlt   string
18642                                 SrcAlt       string
18643                                 Viscosity    uint8 // 0-7
18644                                 LiqRenewable bool
18645                                 FlowRange    uint8
18646                                 DrownDmg     uint8
18647                                 Floodable    bool
18648
18649                                 DrawBox, ColBox, SelBox NodeBox
18650
18651                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18652
18653                                 LegacyFaceDir bool
18654                                 LegacyMounted bool
18655
18656                                 DigPredict string
18657
18658                                 MaxLvl uint8
18659
18660                                 AlphaUse
18661                         }))(obj)).MaxLvl
18662                         write8(w, uint8(x))
18663                 }
18664                 if err := pcall(func() {
18665                         ((*(*(struct {
18666                                 Param0 Content
18667
18668                                 Name   string
18669                                 Groups []Group
18670
18671                                 P1Type   Param1Type
18672                                 P2Type   Param2Type
18673                                 DrawType DrawType
18674
18675                                 Mesh  string
18676                                 Scale float32
18677                                 //mt:const uint8(6)
18678                                 Tiles        [6]TileDef
18679                                 OverlayTiles [6]TileDef
18680                                 //mt:const uint8(6)
18681                                 SpecialTiles [6]TileDef
18682
18683                                 Color   color.NRGBA
18684                                 Palette Texture
18685
18686                                 Waving       WaveType
18687                                 ConnectSides uint8
18688                                 ConnectTo    []Content
18689                                 InsideTint   color.NRGBA
18690                                 Level        uint8 // Must be < 128.
18691
18692                                 Translucent bool // Sunlight is scattered and becomes normal light.
18693                                 Transparent bool // Sunlight isn't scattered.
18694                                 LightSrc    uint8
18695
18696                                 GndContent   bool
18697                                 Collides     bool
18698                                 Pointable    bool
18699                                 Diggable     bool
18700                                 Climbable    bool
18701                                 Replaceable  bool
18702                                 OnRightClick bool
18703
18704                                 DmgPerSec int32
18705
18706                                 LiquidType   LiquidType
18707                                 FlowingAlt   string
18708                                 SrcAlt       string
18709                                 Viscosity    uint8 // 0-7
18710                                 LiqRenewable bool
18711                                 FlowRange    uint8
18712                                 DrownDmg     uint8
18713                                 Floodable    bool
18714
18715                                 DrawBox, ColBox, SelBox NodeBox
18716
18717                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18718
18719                                 LegacyFaceDir bool
18720                                 LegacyMounted bool
18721
18722                                 DigPredict string
18723
18724                                 MaxLvl uint8
18725
18726                                 AlphaUse
18727                         }))(obj)).AlphaUse).serialize(w)
18728                 }); err != nil {
18729                         if err == io.EOF {
18730                                 chk(io.EOF)
18731                         }
18732                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
18733                 }
18734                 {
18735                         buf := w
18736                         w := ow
18737                         if len((buf.Bytes())) > math.MaxUint16 {
18738                                 chk(ErrTooLong)
18739                         }
18740                         {
18741                                 x := uint16(len((buf.Bytes())))
18742                                 write16(w, uint16(x))
18743                         }
18744                         {
18745                                 _, err := w.Write((buf.Bytes())[:])
18746                                 chk(err)
18747                         }
18748                 }
18749         }
18750 }
18751
18752 func (obj *NodeDef) deserialize(r io.Reader) {
18753         if err := pcall(func() {
18754                 ((*(*(struct {
18755                         Param0 Content
18756
18757                         Name   string
18758                         Groups []Group
18759
18760                         P1Type   Param1Type
18761                         P2Type   Param2Type
18762                         DrawType DrawType
18763
18764                         Mesh  string
18765                         Scale float32
18766                         //mt:const uint8(6)
18767                         Tiles        [6]TileDef
18768                         OverlayTiles [6]TileDef
18769                         //mt:const uint8(6)
18770                         SpecialTiles [6]TileDef
18771
18772                         Color   color.NRGBA
18773                         Palette Texture
18774
18775                         Waving       WaveType
18776                         ConnectSides uint8
18777                         ConnectTo    []Content
18778                         InsideTint   color.NRGBA
18779                         Level        uint8 // Must be < 128.
18780
18781                         Translucent bool // Sunlight is scattered and becomes normal light.
18782                         Transparent bool // Sunlight isn't scattered.
18783                         LightSrc    uint8
18784
18785                         GndContent   bool
18786                         Collides     bool
18787                         Pointable    bool
18788                         Diggable     bool
18789                         Climbable    bool
18790                         Replaceable  bool
18791                         OnRightClick bool
18792
18793                         DmgPerSec int32
18794
18795                         LiquidType   LiquidType
18796                         FlowingAlt   string
18797                         SrcAlt       string
18798                         Viscosity    uint8 // 0-7
18799                         LiqRenewable bool
18800                         FlowRange    uint8
18801                         DrownDmg     uint8
18802                         Floodable    bool
18803
18804                         DrawBox, ColBox, SelBox NodeBox
18805
18806                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18807
18808                         LegacyFaceDir bool
18809                         LegacyMounted bool
18810
18811                         DigPredict string
18812
18813                         MaxLvl uint8
18814
18815                         AlphaUse
18816                 }))(obj)).Param0).deserialize(r)
18817         }); err != nil {
18818                 if err == io.EOF {
18819                         chk(io.EOF)
18820                 }
18821                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
18822         }
18823         {
18824                 var n uint16
18825                 {
18826                         p := &n
18827                         *p = read16(r)
18828                 }
18829                 r := &io.LimitedReader{R: r, N: int64(n)}
18830                 {
18831                         var local246 uint8
18832                         local247 := uint8(13)
18833                         {
18834                                 p := &local246
18835                                 *p = read8(r)
18836                         }
18837                         if local246 != local247 {
18838                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local246))
18839                         }
18840                 }
18841                 var local248 []uint8
18842                 var local249 uint16
18843                 {
18844                         p := &local249
18845                         *p = read16(r)
18846                 }
18847                 (local248) = make([]uint8, local249)
18848                 {
18849                         _, err := io.ReadFull(r, (local248)[:])
18850                         chk(err)
18851                 }
18852                 ((*(*(struct {
18853                         Param0 Content
18854
18855                         Name   string
18856                         Groups []Group
18857
18858                         P1Type   Param1Type
18859                         P2Type   Param2Type
18860                         DrawType DrawType
18861
18862                         Mesh  string
18863                         Scale float32
18864                         //mt:const uint8(6)
18865                         Tiles        [6]TileDef
18866                         OverlayTiles [6]TileDef
18867                         //mt:const uint8(6)
18868                         SpecialTiles [6]TileDef
18869
18870                         Color   color.NRGBA
18871                         Palette Texture
18872
18873                         Waving       WaveType
18874                         ConnectSides uint8
18875                         ConnectTo    []Content
18876                         InsideTint   color.NRGBA
18877                         Level        uint8 // Must be < 128.
18878
18879                         Translucent bool // Sunlight is scattered and becomes normal light.
18880                         Transparent bool // Sunlight isn't scattered.
18881                         LightSrc    uint8
18882
18883                         GndContent   bool
18884                         Collides     bool
18885                         Pointable    bool
18886                         Diggable     bool
18887                         Climbable    bool
18888                         Replaceable  bool
18889                         OnRightClick bool
18890
18891                         DmgPerSec int32
18892
18893                         LiquidType   LiquidType
18894                         FlowingAlt   string
18895                         SrcAlt       string
18896                         Viscosity    uint8 // 0-7
18897                         LiqRenewable bool
18898                         FlowRange    uint8
18899                         DrownDmg     uint8
18900                         Floodable    bool
18901
18902                         DrawBox, ColBox, SelBox NodeBox
18903
18904                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18905
18906                         LegacyFaceDir bool
18907                         LegacyMounted bool
18908
18909                         DigPredict string
18910
18911                         MaxLvl uint8
18912
18913                         AlphaUse
18914                 }))(obj)).Name) = string(local248)
18915                 var local250 uint16
18916                 {
18917                         p := &local250
18918                         *p = read16(r)
18919                 }
18920                 ((*(*(struct {
18921                         Param0 Content
18922
18923                         Name   string
18924                         Groups []Group
18925
18926                         P1Type   Param1Type
18927                         P2Type   Param2Type
18928                         DrawType DrawType
18929
18930                         Mesh  string
18931                         Scale float32
18932                         //mt:const uint8(6)
18933                         Tiles        [6]TileDef
18934                         OverlayTiles [6]TileDef
18935                         //mt:const uint8(6)
18936                         SpecialTiles [6]TileDef
18937
18938                         Color   color.NRGBA
18939                         Palette Texture
18940
18941                         Waving       WaveType
18942                         ConnectSides uint8
18943                         ConnectTo    []Content
18944                         InsideTint   color.NRGBA
18945                         Level        uint8 // Must be < 128.
18946
18947                         Translucent bool // Sunlight is scattered and becomes normal light.
18948                         Transparent bool // Sunlight isn't scattered.
18949                         LightSrc    uint8
18950
18951                         GndContent   bool
18952                         Collides     bool
18953                         Pointable    bool
18954                         Diggable     bool
18955                         Climbable    bool
18956                         Replaceable  bool
18957                         OnRightClick bool
18958
18959                         DmgPerSec int32
18960
18961                         LiquidType   LiquidType
18962                         FlowingAlt   string
18963                         SrcAlt       string
18964                         Viscosity    uint8 // 0-7
18965                         LiqRenewable bool
18966                         FlowRange    uint8
18967                         DrownDmg     uint8
18968                         Floodable    bool
18969
18970                         DrawBox, ColBox, SelBox NodeBox
18971
18972                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18973
18974                         LegacyFaceDir bool
18975                         LegacyMounted bool
18976
18977                         DigPredict string
18978
18979                         MaxLvl uint8
18980
18981                         AlphaUse
18982                 }))(obj)).Groups) = make([]Group, local250)
18983                 for local251 := range (*(*(struct {
18984                         Param0 Content
18985
18986                         Name   string
18987                         Groups []Group
18988
18989                         P1Type   Param1Type
18990                         P2Type   Param2Type
18991                         DrawType DrawType
18992
18993                         Mesh  string
18994                         Scale float32
18995                         //mt:const uint8(6)
18996                         Tiles        [6]TileDef
18997                         OverlayTiles [6]TileDef
18998                         //mt:const uint8(6)
18999                         SpecialTiles [6]TileDef
19000
19001                         Color   color.NRGBA
19002                         Palette Texture
19003
19004                         Waving       WaveType
19005                         ConnectSides uint8
19006                         ConnectTo    []Content
19007                         InsideTint   color.NRGBA
19008                         Level        uint8 // Must be < 128.
19009
19010                         Translucent bool // Sunlight is scattered and becomes normal light.
19011                         Transparent bool // Sunlight isn't scattered.
19012                         LightSrc    uint8
19013
19014                         GndContent   bool
19015                         Collides     bool
19016                         Pointable    bool
19017                         Diggable     bool
19018                         Climbable    bool
19019                         Replaceable  bool
19020                         OnRightClick bool
19021
19022                         DmgPerSec int32
19023
19024                         LiquidType   LiquidType
19025                         FlowingAlt   string
19026                         SrcAlt       string
19027                         Viscosity    uint8 // 0-7
19028                         LiqRenewable bool
19029                         FlowRange    uint8
19030                         DrownDmg     uint8
19031                         Floodable    bool
19032
19033                         DrawBox, ColBox, SelBox NodeBox
19034
19035                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19036
19037                         LegacyFaceDir bool
19038                         LegacyMounted bool
19039
19040                         DigPredict string
19041
19042                         MaxLvl uint8
19043
19044                         AlphaUse
19045                 }))(obj)).Groups {
19046                         if err := pcall(func() {
19047                                 (((*(*(struct {
19048                                         Param0 Content
19049
19050                                         Name   string
19051                                         Groups []Group
19052
19053                                         P1Type   Param1Type
19054                                         P2Type   Param2Type
19055                                         DrawType DrawType
19056
19057                                         Mesh  string
19058                                         Scale float32
19059                                         //mt:const uint8(6)
19060                                         Tiles        [6]TileDef
19061                                         OverlayTiles [6]TileDef
19062                                         //mt:const uint8(6)
19063                                         SpecialTiles [6]TileDef
19064
19065                                         Color   color.NRGBA
19066                                         Palette Texture
19067
19068                                         Waving       WaveType
19069                                         ConnectSides uint8
19070                                         ConnectTo    []Content
19071                                         InsideTint   color.NRGBA
19072                                         Level        uint8 // Must be < 128.
19073
19074                                         Translucent bool // Sunlight is scattered and becomes normal light.
19075                                         Transparent bool // Sunlight isn't scattered.
19076                                         LightSrc    uint8
19077
19078                                         GndContent   bool
19079                                         Collides     bool
19080                                         Pointable    bool
19081                                         Diggable     bool
19082                                         Climbable    bool
19083                                         Replaceable  bool
19084                                         OnRightClick bool
19085
19086                                         DmgPerSec int32
19087
19088                                         LiquidType   LiquidType
19089                                         FlowingAlt   string
19090                                         SrcAlt       string
19091                                         Viscosity    uint8 // 0-7
19092                                         LiqRenewable bool
19093                                         FlowRange    uint8
19094                                         DrownDmg     uint8
19095                                         Floodable    bool
19096
19097                                         DrawBox, ColBox, SelBox NodeBox
19098
19099                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19100
19101                                         LegacyFaceDir bool
19102                                         LegacyMounted bool
19103
19104                                         DigPredict string
19105
19106                                         MaxLvl uint8
19107
19108                                         AlphaUse
19109                                 }))(obj)).Groups)[local251]).deserialize(r)
19110                         }); err != nil {
19111                                 if err == io.EOF {
19112                                         chk(io.EOF)
19113                                 }
19114                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
19115                         }
19116                 }
19117                 if err := pcall(func() {
19118                         ((*(*(struct {
19119                                 Param0 Content
19120
19121                                 Name   string
19122                                 Groups []Group
19123
19124                                 P1Type   Param1Type
19125                                 P2Type   Param2Type
19126                                 DrawType DrawType
19127
19128                                 Mesh  string
19129                                 Scale float32
19130                                 //mt:const uint8(6)
19131                                 Tiles        [6]TileDef
19132                                 OverlayTiles [6]TileDef
19133                                 //mt:const uint8(6)
19134                                 SpecialTiles [6]TileDef
19135
19136                                 Color   color.NRGBA
19137                                 Palette Texture
19138
19139                                 Waving       WaveType
19140                                 ConnectSides uint8
19141                                 ConnectTo    []Content
19142                                 InsideTint   color.NRGBA
19143                                 Level        uint8 // Must be < 128.
19144
19145                                 Translucent bool // Sunlight is scattered and becomes normal light.
19146                                 Transparent bool // Sunlight isn't scattered.
19147                                 LightSrc    uint8
19148
19149                                 GndContent   bool
19150                                 Collides     bool
19151                                 Pointable    bool
19152                                 Diggable     bool
19153                                 Climbable    bool
19154                                 Replaceable  bool
19155                                 OnRightClick bool
19156
19157                                 DmgPerSec int32
19158
19159                                 LiquidType   LiquidType
19160                                 FlowingAlt   string
19161                                 SrcAlt       string
19162                                 Viscosity    uint8 // 0-7
19163                                 LiqRenewable bool
19164                                 FlowRange    uint8
19165                                 DrownDmg     uint8
19166                                 Floodable    bool
19167
19168                                 DrawBox, ColBox, SelBox NodeBox
19169
19170                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19171
19172                                 LegacyFaceDir bool
19173                                 LegacyMounted bool
19174
19175                                 DigPredict string
19176
19177                                 MaxLvl uint8
19178
19179                                 AlphaUse
19180                         }))(obj)).P1Type).deserialize(r)
19181                 }); err != nil {
19182                         if err == io.EOF {
19183                                 chk(io.EOF)
19184                         }
19185                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
19186                 }
19187                 if err := pcall(func() {
19188                         ((*(*(struct {
19189                                 Param0 Content
19190
19191                                 Name   string
19192                                 Groups []Group
19193
19194                                 P1Type   Param1Type
19195                                 P2Type   Param2Type
19196                                 DrawType DrawType
19197
19198                                 Mesh  string
19199                                 Scale float32
19200                                 //mt:const uint8(6)
19201                                 Tiles        [6]TileDef
19202                                 OverlayTiles [6]TileDef
19203                                 //mt:const uint8(6)
19204                                 SpecialTiles [6]TileDef
19205
19206                                 Color   color.NRGBA
19207                                 Palette Texture
19208
19209                                 Waving       WaveType
19210                                 ConnectSides uint8
19211                                 ConnectTo    []Content
19212                                 InsideTint   color.NRGBA
19213                                 Level        uint8 // Must be < 128.
19214
19215                                 Translucent bool // Sunlight is scattered and becomes normal light.
19216                                 Transparent bool // Sunlight isn't scattered.
19217                                 LightSrc    uint8
19218
19219                                 GndContent   bool
19220                                 Collides     bool
19221                                 Pointable    bool
19222                                 Diggable     bool
19223                                 Climbable    bool
19224                                 Replaceable  bool
19225                                 OnRightClick bool
19226
19227                                 DmgPerSec int32
19228
19229                                 LiquidType   LiquidType
19230                                 FlowingAlt   string
19231                                 SrcAlt       string
19232                                 Viscosity    uint8 // 0-7
19233                                 LiqRenewable bool
19234                                 FlowRange    uint8
19235                                 DrownDmg     uint8
19236                                 Floodable    bool
19237
19238                                 DrawBox, ColBox, SelBox NodeBox
19239
19240                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19241
19242                                 LegacyFaceDir bool
19243                                 LegacyMounted bool
19244
19245                                 DigPredict string
19246
19247                                 MaxLvl uint8
19248
19249                                 AlphaUse
19250                         }))(obj)).P2Type).deserialize(r)
19251                 }); err != nil {
19252                         if err == io.EOF {
19253                                 chk(io.EOF)
19254                         }
19255                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
19256                 }
19257                 if err := pcall(func() {
19258                         ((*(*(struct {
19259                                 Param0 Content
19260
19261                                 Name   string
19262                                 Groups []Group
19263
19264                                 P1Type   Param1Type
19265                                 P2Type   Param2Type
19266                                 DrawType DrawType
19267
19268                                 Mesh  string
19269                                 Scale float32
19270                                 //mt:const uint8(6)
19271                                 Tiles        [6]TileDef
19272                                 OverlayTiles [6]TileDef
19273                                 //mt:const uint8(6)
19274                                 SpecialTiles [6]TileDef
19275
19276                                 Color   color.NRGBA
19277                                 Palette Texture
19278
19279                                 Waving       WaveType
19280                                 ConnectSides uint8
19281                                 ConnectTo    []Content
19282                                 InsideTint   color.NRGBA
19283                                 Level        uint8 // Must be < 128.
19284
19285                                 Translucent bool // Sunlight is scattered and becomes normal light.
19286                                 Transparent bool // Sunlight isn't scattered.
19287                                 LightSrc    uint8
19288
19289                                 GndContent   bool
19290                                 Collides     bool
19291                                 Pointable    bool
19292                                 Diggable     bool
19293                                 Climbable    bool
19294                                 Replaceable  bool
19295                                 OnRightClick bool
19296
19297                                 DmgPerSec int32
19298
19299                                 LiquidType   LiquidType
19300                                 FlowingAlt   string
19301                                 SrcAlt       string
19302                                 Viscosity    uint8 // 0-7
19303                                 LiqRenewable bool
19304                                 FlowRange    uint8
19305                                 DrownDmg     uint8
19306                                 Floodable    bool
19307
19308                                 DrawBox, ColBox, SelBox NodeBox
19309
19310                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19311
19312                                 LegacyFaceDir bool
19313                                 LegacyMounted bool
19314
19315                                 DigPredict string
19316
19317                                 MaxLvl uint8
19318
19319                                 AlphaUse
19320                         }))(obj)).DrawType).deserialize(r)
19321                 }); err != nil {
19322                         if err == io.EOF {
19323                                 chk(io.EOF)
19324                         }
19325                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
19326                 }
19327                 var local252 []uint8
19328                 var local253 uint16
19329                 {
19330                         p := &local253
19331                         *p = read16(r)
19332                 }
19333                 (local252) = make([]uint8, local253)
19334                 {
19335                         _, err := io.ReadFull(r, (local252)[:])
19336                         chk(err)
19337                 }
19338                 ((*(*(struct {
19339                         Param0 Content
19340
19341                         Name   string
19342                         Groups []Group
19343
19344                         P1Type   Param1Type
19345                         P2Type   Param2Type
19346                         DrawType DrawType
19347
19348                         Mesh  string
19349                         Scale float32
19350                         //mt:const uint8(6)
19351                         Tiles        [6]TileDef
19352                         OverlayTiles [6]TileDef
19353                         //mt:const uint8(6)
19354                         SpecialTiles [6]TileDef
19355
19356                         Color   color.NRGBA
19357                         Palette Texture
19358
19359                         Waving       WaveType
19360                         ConnectSides uint8
19361                         ConnectTo    []Content
19362                         InsideTint   color.NRGBA
19363                         Level        uint8 // Must be < 128.
19364
19365                         Translucent bool // Sunlight is scattered and becomes normal light.
19366                         Transparent bool // Sunlight isn't scattered.
19367                         LightSrc    uint8
19368
19369                         GndContent   bool
19370                         Collides     bool
19371                         Pointable    bool
19372                         Diggable     bool
19373                         Climbable    bool
19374                         Replaceable  bool
19375                         OnRightClick bool
19376
19377                         DmgPerSec int32
19378
19379                         LiquidType   LiquidType
19380                         FlowingAlt   string
19381                         SrcAlt       string
19382                         Viscosity    uint8 // 0-7
19383                         LiqRenewable bool
19384                         FlowRange    uint8
19385                         DrownDmg     uint8
19386                         Floodable    bool
19387
19388                         DrawBox, ColBox, SelBox NodeBox
19389
19390                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19391
19392                         LegacyFaceDir bool
19393                         LegacyMounted bool
19394
19395                         DigPredict string
19396
19397                         MaxLvl uint8
19398
19399                         AlphaUse
19400                 }))(obj)).Mesh) = string(local252)
19401                 {
19402                         p := &(*(*(struct {
19403                                 Param0 Content
19404
19405                                 Name   string
19406                                 Groups []Group
19407
19408                                 P1Type   Param1Type
19409                                 P2Type   Param2Type
19410                                 DrawType DrawType
19411
19412                                 Mesh  string
19413                                 Scale float32
19414                                 //mt:const uint8(6)
19415                                 Tiles        [6]TileDef
19416                                 OverlayTiles [6]TileDef
19417                                 //mt:const uint8(6)
19418                                 SpecialTiles [6]TileDef
19419
19420                                 Color   color.NRGBA
19421                                 Palette Texture
19422
19423                                 Waving       WaveType
19424                                 ConnectSides uint8
19425                                 ConnectTo    []Content
19426                                 InsideTint   color.NRGBA
19427                                 Level        uint8 // Must be < 128.
19428
19429                                 Translucent bool // Sunlight is scattered and becomes normal light.
19430                                 Transparent bool // Sunlight isn't scattered.
19431                                 LightSrc    uint8
19432
19433                                 GndContent   bool
19434                                 Collides     bool
19435                                 Pointable    bool
19436                                 Diggable     bool
19437                                 Climbable    bool
19438                                 Replaceable  bool
19439                                 OnRightClick bool
19440
19441                                 DmgPerSec int32
19442
19443                                 LiquidType   LiquidType
19444                                 FlowingAlt   string
19445                                 SrcAlt       string
19446                                 Viscosity    uint8 // 0-7
19447                                 LiqRenewable bool
19448                                 FlowRange    uint8
19449                                 DrownDmg     uint8
19450                                 Floodable    bool
19451
19452                                 DrawBox, ColBox, SelBox NodeBox
19453
19454                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19455
19456                                 LegacyFaceDir bool
19457                                 LegacyMounted bool
19458
19459                                 DigPredict string
19460
19461                                 MaxLvl uint8
19462
19463                                 AlphaUse
19464                         }))(obj)).Scale
19465                         *p = math.Float32frombits(read32(r))
19466                 }
19467                 {
19468                         var local254 uint8
19469                         local255 := uint8(6)
19470                         {
19471                                 p := &local254
19472                                 *p = read8(r)
19473                         }
19474                         if local254 != local255 {
19475                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local254))
19476                         }
19477                 }
19478                 for local256 := range (*(*(struct {
19479                         Param0 Content
19480
19481                         Name   string
19482                         Groups []Group
19483
19484                         P1Type   Param1Type
19485                         P2Type   Param2Type
19486                         DrawType DrawType
19487
19488                         Mesh  string
19489                         Scale float32
19490                         //mt:const uint8(6)
19491                         Tiles        [6]TileDef
19492                         OverlayTiles [6]TileDef
19493                         //mt:const uint8(6)
19494                         SpecialTiles [6]TileDef
19495
19496                         Color   color.NRGBA
19497                         Palette Texture
19498
19499                         Waving       WaveType
19500                         ConnectSides uint8
19501                         ConnectTo    []Content
19502                         InsideTint   color.NRGBA
19503                         Level        uint8 // Must be < 128.
19504
19505                         Translucent bool // Sunlight is scattered and becomes normal light.
19506                         Transparent bool // Sunlight isn't scattered.
19507                         LightSrc    uint8
19508
19509                         GndContent   bool
19510                         Collides     bool
19511                         Pointable    bool
19512                         Diggable     bool
19513                         Climbable    bool
19514                         Replaceable  bool
19515                         OnRightClick bool
19516
19517                         DmgPerSec int32
19518
19519                         LiquidType   LiquidType
19520                         FlowingAlt   string
19521                         SrcAlt       string
19522                         Viscosity    uint8 // 0-7
19523                         LiqRenewable bool
19524                         FlowRange    uint8
19525                         DrownDmg     uint8
19526                         Floodable    bool
19527
19528                         DrawBox, ColBox, SelBox NodeBox
19529
19530                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19531
19532                         LegacyFaceDir bool
19533                         LegacyMounted bool
19534
19535                         DigPredict string
19536
19537                         MaxLvl uint8
19538
19539                         AlphaUse
19540                 }))(obj)).Tiles {
19541                         if err := pcall(func() {
19542                                 (((*(*(struct {
19543                                         Param0 Content
19544
19545                                         Name   string
19546                                         Groups []Group
19547
19548                                         P1Type   Param1Type
19549                                         P2Type   Param2Type
19550                                         DrawType DrawType
19551
19552                                         Mesh  string
19553                                         Scale float32
19554                                         //mt:const uint8(6)
19555                                         Tiles        [6]TileDef
19556                                         OverlayTiles [6]TileDef
19557                                         //mt:const uint8(6)
19558                                         SpecialTiles [6]TileDef
19559
19560                                         Color   color.NRGBA
19561                                         Palette Texture
19562
19563                                         Waving       WaveType
19564                                         ConnectSides uint8
19565                                         ConnectTo    []Content
19566                                         InsideTint   color.NRGBA
19567                                         Level        uint8 // Must be < 128.
19568
19569                                         Translucent bool // Sunlight is scattered and becomes normal light.
19570                                         Transparent bool // Sunlight isn't scattered.
19571                                         LightSrc    uint8
19572
19573                                         GndContent   bool
19574                                         Collides     bool
19575                                         Pointable    bool
19576                                         Diggable     bool
19577                                         Climbable    bool
19578                                         Replaceable  bool
19579                                         OnRightClick bool
19580
19581                                         DmgPerSec int32
19582
19583                                         LiquidType   LiquidType
19584                                         FlowingAlt   string
19585                                         SrcAlt       string
19586                                         Viscosity    uint8 // 0-7
19587                                         LiqRenewable bool
19588                                         FlowRange    uint8
19589                                         DrownDmg     uint8
19590                                         Floodable    bool
19591
19592                                         DrawBox, ColBox, SelBox NodeBox
19593
19594                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19595
19596                                         LegacyFaceDir bool
19597                                         LegacyMounted bool
19598
19599                                         DigPredict string
19600
19601                                         MaxLvl uint8
19602
19603                                         AlphaUse
19604                                 }))(obj)).Tiles)[local256]).deserialize(r)
19605                         }); err != nil {
19606                                 if err == io.EOF {
19607                                         chk(io.EOF)
19608                                 }
19609                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
19610                         }
19611                 }
19612                 for local257 := range (*(*(struct {
19613                         Param0 Content
19614
19615                         Name   string
19616                         Groups []Group
19617
19618                         P1Type   Param1Type
19619                         P2Type   Param2Type
19620                         DrawType DrawType
19621
19622                         Mesh  string
19623                         Scale float32
19624                         //mt:const uint8(6)
19625                         Tiles        [6]TileDef
19626                         OverlayTiles [6]TileDef
19627                         //mt:const uint8(6)
19628                         SpecialTiles [6]TileDef
19629
19630                         Color   color.NRGBA
19631                         Palette Texture
19632
19633                         Waving       WaveType
19634                         ConnectSides uint8
19635                         ConnectTo    []Content
19636                         InsideTint   color.NRGBA
19637                         Level        uint8 // Must be < 128.
19638
19639                         Translucent bool // Sunlight is scattered and becomes normal light.
19640                         Transparent bool // Sunlight isn't scattered.
19641                         LightSrc    uint8
19642
19643                         GndContent   bool
19644                         Collides     bool
19645                         Pointable    bool
19646                         Diggable     bool
19647                         Climbable    bool
19648                         Replaceable  bool
19649                         OnRightClick bool
19650
19651                         DmgPerSec int32
19652
19653                         LiquidType   LiquidType
19654                         FlowingAlt   string
19655                         SrcAlt       string
19656                         Viscosity    uint8 // 0-7
19657                         LiqRenewable bool
19658                         FlowRange    uint8
19659                         DrownDmg     uint8
19660                         Floodable    bool
19661
19662                         DrawBox, ColBox, SelBox NodeBox
19663
19664                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19665
19666                         LegacyFaceDir bool
19667                         LegacyMounted bool
19668
19669                         DigPredict string
19670
19671                         MaxLvl uint8
19672
19673                         AlphaUse
19674                 }))(obj)).OverlayTiles {
19675                         if err := pcall(func() {
19676                                 (((*(*(struct {
19677                                         Param0 Content
19678
19679                                         Name   string
19680                                         Groups []Group
19681
19682                                         P1Type   Param1Type
19683                                         P2Type   Param2Type
19684                                         DrawType DrawType
19685
19686                                         Mesh  string
19687                                         Scale float32
19688                                         //mt:const uint8(6)
19689                                         Tiles        [6]TileDef
19690                                         OverlayTiles [6]TileDef
19691                                         //mt:const uint8(6)
19692                                         SpecialTiles [6]TileDef
19693
19694                                         Color   color.NRGBA
19695                                         Palette Texture
19696
19697                                         Waving       WaveType
19698                                         ConnectSides uint8
19699                                         ConnectTo    []Content
19700                                         InsideTint   color.NRGBA
19701                                         Level        uint8 // Must be < 128.
19702
19703                                         Translucent bool // Sunlight is scattered and becomes normal light.
19704                                         Transparent bool // Sunlight isn't scattered.
19705                                         LightSrc    uint8
19706
19707                                         GndContent   bool
19708                                         Collides     bool
19709                                         Pointable    bool
19710                                         Diggable     bool
19711                                         Climbable    bool
19712                                         Replaceable  bool
19713                                         OnRightClick bool
19714
19715                                         DmgPerSec int32
19716
19717                                         LiquidType   LiquidType
19718                                         FlowingAlt   string
19719                                         SrcAlt       string
19720                                         Viscosity    uint8 // 0-7
19721                                         LiqRenewable bool
19722                                         FlowRange    uint8
19723                                         DrownDmg     uint8
19724                                         Floodable    bool
19725
19726                                         DrawBox, ColBox, SelBox NodeBox
19727
19728                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19729
19730                                         LegacyFaceDir bool
19731                                         LegacyMounted bool
19732
19733                                         DigPredict string
19734
19735                                         MaxLvl uint8
19736
19737                                         AlphaUse
19738                                 }))(obj)).OverlayTiles)[local257]).deserialize(r)
19739                         }); err != nil {
19740                                 if err == io.EOF {
19741                                         chk(io.EOF)
19742                                 }
19743                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
19744                         }
19745                 }
19746                 {
19747                         var local258 uint8
19748                         local259 := uint8(6)
19749                         {
19750                                 p := &local258
19751                                 *p = read8(r)
19752                         }
19753                         if local258 != local259 {
19754                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local258))
19755                         }
19756                 }
19757                 for local260 := range (*(*(struct {
19758                         Param0 Content
19759
19760                         Name   string
19761                         Groups []Group
19762
19763                         P1Type   Param1Type
19764                         P2Type   Param2Type
19765                         DrawType DrawType
19766
19767                         Mesh  string
19768                         Scale float32
19769                         //mt:const uint8(6)
19770                         Tiles        [6]TileDef
19771                         OverlayTiles [6]TileDef
19772                         //mt:const uint8(6)
19773                         SpecialTiles [6]TileDef
19774
19775                         Color   color.NRGBA
19776                         Palette Texture
19777
19778                         Waving       WaveType
19779                         ConnectSides uint8
19780                         ConnectTo    []Content
19781                         InsideTint   color.NRGBA
19782                         Level        uint8 // Must be < 128.
19783
19784                         Translucent bool // Sunlight is scattered and becomes normal light.
19785                         Transparent bool // Sunlight isn't scattered.
19786                         LightSrc    uint8
19787
19788                         GndContent   bool
19789                         Collides     bool
19790                         Pointable    bool
19791                         Diggable     bool
19792                         Climbable    bool
19793                         Replaceable  bool
19794                         OnRightClick bool
19795
19796                         DmgPerSec int32
19797
19798                         LiquidType   LiquidType
19799                         FlowingAlt   string
19800                         SrcAlt       string
19801                         Viscosity    uint8 // 0-7
19802                         LiqRenewable bool
19803                         FlowRange    uint8
19804                         DrownDmg     uint8
19805                         Floodable    bool
19806
19807                         DrawBox, ColBox, SelBox NodeBox
19808
19809                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19810
19811                         LegacyFaceDir bool
19812                         LegacyMounted bool
19813
19814                         DigPredict string
19815
19816                         MaxLvl uint8
19817
19818                         AlphaUse
19819                 }))(obj)).SpecialTiles {
19820                         if err := pcall(func() {
19821                                 (((*(*(struct {
19822                                         Param0 Content
19823
19824                                         Name   string
19825                                         Groups []Group
19826
19827                                         P1Type   Param1Type
19828                                         P2Type   Param2Type
19829                                         DrawType DrawType
19830
19831                                         Mesh  string
19832                                         Scale float32
19833                                         //mt:const uint8(6)
19834                                         Tiles        [6]TileDef
19835                                         OverlayTiles [6]TileDef
19836                                         //mt:const uint8(6)
19837                                         SpecialTiles [6]TileDef
19838
19839                                         Color   color.NRGBA
19840                                         Palette Texture
19841
19842                                         Waving       WaveType
19843                                         ConnectSides uint8
19844                                         ConnectTo    []Content
19845                                         InsideTint   color.NRGBA
19846                                         Level        uint8 // Must be < 128.
19847
19848                                         Translucent bool // Sunlight is scattered and becomes normal light.
19849                                         Transparent bool // Sunlight isn't scattered.
19850                                         LightSrc    uint8
19851
19852                                         GndContent   bool
19853                                         Collides     bool
19854                                         Pointable    bool
19855                                         Diggable     bool
19856                                         Climbable    bool
19857                                         Replaceable  bool
19858                                         OnRightClick bool
19859
19860                                         DmgPerSec int32
19861
19862                                         LiquidType   LiquidType
19863                                         FlowingAlt   string
19864                                         SrcAlt       string
19865                                         Viscosity    uint8 // 0-7
19866                                         LiqRenewable bool
19867                                         FlowRange    uint8
19868                                         DrownDmg     uint8
19869                                         Floodable    bool
19870
19871                                         DrawBox, ColBox, SelBox NodeBox
19872
19873                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19874
19875                                         LegacyFaceDir bool
19876                                         LegacyMounted bool
19877
19878                                         DigPredict string
19879
19880                                         MaxLvl uint8
19881
19882                                         AlphaUse
19883                                 }))(obj)).SpecialTiles)[local260]).deserialize(r)
19884                         }); err != nil {
19885                                 if err == io.EOF {
19886                                         chk(io.EOF)
19887                                 }
19888                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
19889                         }
19890                 }
19891                 {
19892                         p := &(*(*(struct {
19893                                 Param0 Content
19894
19895                                 Name   string
19896                                 Groups []Group
19897
19898                                 P1Type   Param1Type
19899                                 P2Type   Param2Type
19900                                 DrawType DrawType
19901
19902                                 Mesh  string
19903                                 Scale float32
19904                                 //mt:const uint8(6)
19905                                 Tiles        [6]TileDef
19906                                 OverlayTiles [6]TileDef
19907                                 //mt:const uint8(6)
19908                                 SpecialTiles [6]TileDef
19909
19910                                 Color   color.NRGBA
19911                                 Palette Texture
19912
19913                                 Waving       WaveType
19914                                 ConnectSides uint8
19915                                 ConnectTo    []Content
19916                                 InsideTint   color.NRGBA
19917                                 Level        uint8 // Must be < 128.
19918
19919                                 Translucent bool // Sunlight is scattered and becomes normal light.
19920                                 Transparent bool // Sunlight isn't scattered.
19921                                 LightSrc    uint8
19922
19923                                 GndContent   bool
19924                                 Collides     bool
19925                                 Pointable    bool
19926                                 Diggable     bool
19927                                 Climbable    bool
19928                                 Replaceable  bool
19929                                 OnRightClick bool
19930
19931                                 DmgPerSec int32
19932
19933                                 LiquidType   LiquidType
19934                                 FlowingAlt   string
19935                                 SrcAlt       string
19936                                 Viscosity    uint8 // 0-7
19937                                 LiqRenewable bool
19938                                 FlowRange    uint8
19939                                 DrownDmg     uint8
19940                                 Floodable    bool
19941
19942                                 DrawBox, ColBox, SelBox NodeBox
19943
19944                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19945
19946                                 LegacyFaceDir bool
19947                                 LegacyMounted bool
19948
19949                                 DigPredict string
19950
19951                                 MaxLvl uint8
19952
19953                                 AlphaUse
19954                         }))(obj)).Color
19955                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
19956                 }
19957                 if err := pcall(func() {
19958                         ((*(*(struct {
19959                                 Param0 Content
19960
19961                                 Name   string
19962                                 Groups []Group
19963
19964                                 P1Type   Param1Type
19965                                 P2Type   Param2Type
19966                                 DrawType DrawType
19967
19968                                 Mesh  string
19969                                 Scale float32
19970                                 //mt:const uint8(6)
19971                                 Tiles        [6]TileDef
19972                                 OverlayTiles [6]TileDef
19973                                 //mt:const uint8(6)
19974                                 SpecialTiles [6]TileDef
19975
19976                                 Color   color.NRGBA
19977                                 Palette Texture
19978
19979                                 Waving       WaveType
19980                                 ConnectSides uint8
19981                                 ConnectTo    []Content
19982                                 InsideTint   color.NRGBA
19983                                 Level        uint8 // Must be < 128.
19984
19985                                 Translucent bool // Sunlight is scattered and becomes normal light.
19986                                 Transparent bool // Sunlight isn't scattered.
19987                                 LightSrc    uint8
19988
19989                                 GndContent   bool
19990                                 Collides     bool
19991                                 Pointable    bool
19992                                 Diggable     bool
19993                                 Climbable    bool
19994                                 Replaceable  bool
19995                                 OnRightClick bool
19996
19997                                 DmgPerSec int32
19998
19999                                 LiquidType   LiquidType
20000                                 FlowingAlt   string
20001                                 SrcAlt       string
20002                                 Viscosity    uint8 // 0-7
20003                                 LiqRenewable bool
20004                                 FlowRange    uint8
20005                                 DrownDmg     uint8
20006                                 Floodable    bool
20007
20008                                 DrawBox, ColBox, SelBox NodeBox
20009
20010                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20011
20012                                 LegacyFaceDir bool
20013                                 LegacyMounted bool
20014
20015                                 DigPredict string
20016
20017                                 MaxLvl uint8
20018
20019                                 AlphaUse
20020                         }))(obj)).Palette).deserialize(r)
20021                 }); err != nil {
20022                         if err == io.EOF {
20023                                 chk(io.EOF)
20024                         }
20025                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
20026                 }
20027                 if err := pcall(func() {
20028                         ((*(*(struct {
20029                                 Param0 Content
20030
20031                                 Name   string
20032                                 Groups []Group
20033
20034                                 P1Type   Param1Type
20035                                 P2Type   Param2Type
20036                                 DrawType DrawType
20037
20038                                 Mesh  string
20039                                 Scale float32
20040                                 //mt:const uint8(6)
20041                                 Tiles        [6]TileDef
20042                                 OverlayTiles [6]TileDef
20043                                 //mt:const uint8(6)
20044                                 SpecialTiles [6]TileDef
20045
20046                                 Color   color.NRGBA
20047                                 Palette Texture
20048
20049                                 Waving       WaveType
20050                                 ConnectSides uint8
20051                                 ConnectTo    []Content
20052                                 InsideTint   color.NRGBA
20053                                 Level        uint8 // Must be < 128.
20054
20055                                 Translucent bool // Sunlight is scattered and becomes normal light.
20056                                 Transparent bool // Sunlight isn't scattered.
20057                                 LightSrc    uint8
20058
20059                                 GndContent   bool
20060                                 Collides     bool
20061                                 Pointable    bool
20062                                 Diggable     bool
20063                                 Climbable    bool
20064                                 Replaceable  bool
20065                                 OnRightClick bool
20066
20067                                 DmgPerSec int32
20068
20069                                 LiquidType   LiquidType
20070                                 FlowingAlt   string
20071                                 SrcAlt       string
20072                                 Viscosity    uint8 // 0-7
20073                                 LiqRenewable bool
20074                                 FlowRange    uint8
20075                                 DrownDmg     uint8
20076                                 Floodable    bool
20077
20078                                 DrawBox, ColBox, SelBox NodeBox
20079
20080                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20081
20082                                 LegacyFaceDir bool
20083                                 LegacyMounted bool
20084
20085                                 DigPredict string
20086
20087                                 MaxLvl uint8
20088
20089                                 AlphaUse
20090                         }))(obj)).Waving).deserialize(r)
20091                 }); err != nil {
20092                         if err == io.EOF {
20093                                 chk(io.EOF)
20094                         }
20095                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
20096                 }
20097                 {
20098                         p := &(*(*(struct {
20099                                 Param0 Content
20100
20101                                 Name   string
20102                                 Groups []Group
20103
20104                                 P1Type   Param1Type
20105                                 P2Type   Param2Type
20106                                 DrawType DrawType
20107
20108                                 Mesh  string
20109                                 Scale float32
20110                                 //mt:const uint8(6)
20111                                 Tiles        [6]TileDef
20112                                 OverlayTiles [6]TileDef
20113                                 //mt:const uint8(6)
20114                                 SpecialTiles [6]TileDef
20115
20116                                 Color   color.NRGBA
20117                                 Palette Texture
20118
20119                                 Waving       WaveType
20120                                 ConnectSides uint8
20121                                 ConnectTo    []Content
20122                                 InsideTint   color.NRGBA
20123                                 Level        uint8 // Must be < 128.
20124
20125                                 Translucent bool // Sunlight is scattered and becomes normal light.
20126                                 Transparent bool // Sunlight isn't scattered.
20127                                 LightSrc    uint8
20128
20129                                 GndContent   bool
20130                                 Collides     bool
20131                                 Pointable    bool
20132                                 Diggable     bool
20133                                 Climbable    bool
20134                                 Replaceable  bool
20135                                 OnRightClick bool
20136
20137                                 DmgPerSec int32
20138
20139                                 LiquidType   LiquidType
20140                                 FlowingAlt   string
20141                                 SrcAlt       string
20142                                 Viscosity    uint8 // 0-7
20143                                 LiqRenewable bool
20144                                 FlowRange    uint8
20145                                 DrownDmg     uint8
20146                                 Floodable    bool
20147
20148                                 DrawBox, ColBox, SelBox NodeBox
20149
20150                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20151
20152                                 LegacyFaceDir bool
20153                                 LegacyMounted bool
20154
20155                                 DigPredict string
20156
20157                                 MaxLvl uint8
20158
20159                                 AlphaUse
20160                         }))(obj)).ConnectSides
20161                         *p = read8(r)
20162                 }
20163                 var local261 uint16
20164                 {
20165                         p := &local261
20166                         *p = read16(r)
20167                 }
20168                 ((*(*(struct {
20169                         Param0 Content
20170
20171                         Name   string
20172                         Groups []Group
20173
20174                         P1Type   Param1Type
20175                         P2Type   Param2Type
20176                         DrawType DrawType
20177
20178                         Mesh  string
20179                         Scale float32
20180                         //mt:const uint8(6)
20181                         Tiles        [6]TileDef
20182                         OverlayTiles [6]TileDef
20183                         //mt:const uint8(6)
20184                         SpecialTiles [6]TileDef
20185
20186                         Color   color.NRGBA
20187                         Palette Texture
20188
20189                         Waving       WaveType
20190                         ConnectSides uint8
20191                         ConnectTo    []Content
20192                         InsideTint   color.NRGBA
20193                         Level        uint8 // Must be < 128.
20194
20195                         Translucent bool // Sunlight is scattered and becomes normal light.
20196                         Transparent bool // Sunlight isn't scattered.
20197                         LightSrc    uint8
20198
20199                         GndContent   bool
20200                         Collides     bool
20201                         Pointable    bool
20202                         Diggable     bool
20203                         Climbable    bool
20204                         Replaceable  bool
20205                         OnRightClick bool
20206
20207                         DmgPerSec int32
20208
20209                         LiquidType   LiquidType
20210                         FlowingAlt   string
20211                         SrcAlt       string
20212                         Viscosity    uint8 // 0-7
20213                         LiqRenewable bool
20214                         FlowRange    uint8
20215                         DrownDmg     uint8
20216                         Floodable    bool
20217
20218                         DrawBox, ColBox, SelBox NodeBox
20219
20220                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20221
20222                         LegacyFaceDir bool
20223                         LegacyMounted bool
20224
20225                         DigPredict string
20226
20227                         MaxLvl uint8
20228
20229                         AlphaUse
20230                 }))(obj)).ConnectTo) = make([]Content, local261)
20231                 for local262 := range (*(*(struct {
20232                         Param0 Content
20233
20234                         Name   string
20235                         Groups []Group
20236
20237                         P1Type   Param1Type
20238                         P2Type   Param2Type
20239                         DrawType DrawType
20240
20241                         Mesh  string
20242                         Scale float32
20243                         //mt:const uint8(6)
20244                         Tiles        [6]TileDef
20245                         OverlayTiles [6]TileDef
20246                         //mt:const uint8(6)
20247                         SpecialTiles [6]TileDef
20248
20249                         Color   color.NRGBA
20250                         Palette Texture
20251
20252                         Waving       WaveType
20253                         ConnectSides uint8
20254                         ConnectTo    []Content
20255                         InsideTint   color.NRGBA
20256                         Level        uint8 // Must be < 128.
20257
20258                         Translucent bool // Sunlight is scattered and becomes normal light.
20259                         Transparent bool // Sunlight isn't scattered.
20260                         LightSrc    uint8
20261
20262                         GndContent   bool
20263                         Collides     bool
20264                         Pointable    bool
20265                         Diggable     bool
20266                         Climbable    bool
20267                         Replaceable  bool
20268                         OnRightClick bool
20269
20270                         DmgPerSec int32
20271
20272                         LiquidType   LiquidType
20273                         FlowingAlt   string
20274                         SrcAlt       string
20275                         Viscosity    uint8 // 0-7
20276                         LiqRenewable bool
20277                         FlowRange    uint8
20278                         DrownDmg     uint8
20279                         Floodable    bool
20280
20281                         DrawBox, ColBox, SelBox NodeBox
20282
20283                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20284
20285                         LegacyFaceDir bool
20286                         LegacyMounted bool
20287
20288                         DigPredict string
20289
20290                         MaxLvl uint8
20291
20292                         AlphaUse
20293                 }))(obj)).ConnectTo {
20294                         if err := pcall(func() {
20295                                 (((*(*(struct {
20296                                         Param0 Content
20297
20298                                         Name   string
20299                                         Groups []Group
20300
20301                                         P1Type   Param1Type
20302                                         P2Type   Param2Type
20303                                         DrawType DrawType
20304
20305                                         Mesh  string
20306                                         Scale float32
20307                                         //mt:const uint8(6)
20308                                         Tiles        [6]TileDef
20309                                         OverlayTiles [6]TileDef
20310                                         //mt:const uint8(6)
20311                                         SpecialTiles [6]TileDef
20312
20313                                         Color   color.NRGBA
20314                                         Palette Texture
20315
20316                                         Waving       WaveType
20317                                         ConnectSides uint8
20318                                         ConnectTo    []Content
20319                                         InsideTint   color.NRGBA
20320                                         Level        uint8 // Must be < 128.
20321
20322                                         Translucent bool // Sunlight is scattered and becomes normal light.
20323                                         Transparent bool // Sunlight isn't scattered.
20324                                         LightSrc    uint8
20325
20326                                         GndContent   bool
20327                                         Collides     bool
20328                                         Pointable    bool
20329                                         Diggable     bool
20330                                         Climbable    bool
20331                                         Replaceable  bool
20332                                         OnRightClick bool
20333
20334                                         DmgPerSec int32
20335
20336                                         LiquidType   LiquidType
20337                                         FlowingAlt   string
20338                                         SrcAlt       string
20339                                         Viscosity    uint8 // 0-7
20340                                         LiqRenewable bool
20341                                         FlowRange    uint8
20342                                         DrownDmg     uint8
20343                                         Floodable    bool
20344
20345                                         DrawBox, ColBox, SelBox NodeBox
20346
20347                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20348
20349                                         LegacyFaceDir bool
20350                                         LegacyMounted bool
20351
20352                                         DigPredict string
20353
20354                                         MaxLvl uint8
20355
20356                                         AlphaUse
20357                                 }))(obj)).ConnectTo)[local262]).deserialize(r)
20358                         }); err != nil {
20359                                 if err == io.EOF {
20360                                         chk(io.EOF)
20361                                 }
20362                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
20363                         }
20364                 }
20365                 {
20366                         p := &(*(*(struct {
20367                                 Param0 Content
20368
20369                                 Name   string
20370                                 Groups []Group
20371
20372                                 P1Type   Param1Type
20373                                 P2Type   Param2Type
20374                                 DrawType DrawType
20375
20376                                 Mesh  string
20377                                 Scale float32
20378                                 //mt:const uint8(6)
20379                                 Tiles        [6]TileDef
20380                                 OverlayTiles [6]TileDef
20381                                 //mt:const uint8(6)
20382                                 SpecialTiles [6]TileDef
20383
20384                                 Color   color.NRGBA
20385                                 Palette Texture
20386
20387                                 Waving       WaveType
20388                                 ConnectSides uint8
20389                                 ConnectTo    []Content
20390                                 InsideTint   color.NRGBA
20391                                 Level        uint8 // Must be < 128.
20392
20393                                 Translucent bool // Sunlight is scattered and becomes normal light.
20394                                 Transparent bool // Sunlight isn't scattered.
20395                                 LightSrc    uint8
20396
20397                                 GndContent   bool
20398                                 Collides     bool
20399                                 Pointable    bool
20400                                 Diggable     bool
20401                                 Climbable    bool
20402                                 Replaceable  bool
20403                                 OnRightClick bool
20404
20405                                 DmgPerSec int32
20406
20407                                 LiquidType   LiquidType
20408                                 FlowingAlt   string
20409                                 SrcAlt       string
20410                                 Viscosity    uint8 // 0-7
20411                                 LiqRenewable bool
20412                                 FlowRange    uint8
20413                                 DrownDmg     uint8
20414                                 Floodable    bool
20415
20416                                 DrawBox, ColBox, SelBox NodeBox
20417
20418                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20419
20420                                 LegacyFaceDir bool
20421                                 LegacyMounted bool
20422
20423                                 DigPredict string
20424
20425                                 MaxLvl uint8
20426
20427                                 AlphaUse
20428                         }))(obj)).InsideTint
20429                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20430                 }
20431                 {
20432                         p := &(*(*(struct {
20433                                 Param0 Content
20434
20435                                 Name   string
20436                                 Groups []Group
20437
20438                                 P1Type   Param1Type
20439                                 P2Type   Param2Type
20440                                 DrawType DrawType
20441
20442                                 Mesh  string
20443                                 Scale float32
20444                                 //mt:const uint8(6)
20445                                 Tiles        [6]TileDef
20446                                 OverlayTiles [6]TileDef
20447                                 //mt:const uint8(6)
20448                                 SpecialTiles [6]TileDef
20449
20450                                 Color   color.NRGBA
20451                                 Palette Texture
20452
20453                                 Waving       WaveType
20454                                 ConnectSides uint8
20455                                 ConnectTo    []Content
20456                                 InsideTint   color.NRGBA
20457                                 Level        uint8 // Must be < 128.
20458
20459                                 Translucent bool // Sunlight is scattered and becomes normal light.
20460                                 Transparent bool // Sunlight isn't scattered.
20461                                 LightSrc    uint8
20462
20463                                 GndContent   bool
20464                                 Collides     bool
20465                                 Pointable    bool
20466                                 Diggable     bool
20467                                 Climbable    bool
20468                                 Replaceable  bool
20469                                 OnRightClick bool
20470
20471                                 DmgPerSec int32
20472
20473                                 LiquidType   LiquidType
20474                                 FlowingAlt   string
20475                                 SrcAlt       string
20476                                 Viscosity    uint8 // 0-7
20477                                 LiqRenewable bool
20478                                 FlowRange    uint8
20479                                 DrownDmg     uint8
20480                                 Floodable    bool
20481
20482                                 DrawBox, ColBox, SelBox NodeBox
20483
20484                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20485
20486                                 LegacyFaceDir bool
20487                                 LegacyMounted bool
20488
20489                                 DigPredict string
20490
20491                                 MaxLvl uint8
20492
20493                                 AlphaUse
20494                         }))(obj)).Level
20495                         *p = read8(r)
20496                 }
20497                 {
20498                         p := &(*(*(struct {
20499                                 Param0 Content
20500
20501                                 Name   string
20502                                 Groups []Group
20503
20504                                 P1Type   Param1Type
20505                                 P2Type   Param2Type
20506                                 DrawType DrawType
20507
20508                                 Mesh  string
20509                                 Scale float32
20510                                 //mt:const uint8(6)
20511                                 Tiles        [6]TileDef
20512                                 OverlayTiles [6]TileDef
20513                                 //mt:const uint8(6)
20514                                 SpecialTiles [6]TileDef
20515
20516                                 Color   color.NRGBA
20517                                 Palette Texture
20518
20519                                 Waving       WaveType
20520                                 ConnectSides uint8
20521                                 ConnectTo    []Content
20522                                 InsideTint   color.NRGBA
20523                                 Level        uint8 // Must be < 128.
20524
20525                                 Translucent bool // Sunlight is scattered and becomes normal light.
20526                                 Transparent bool // Sunlight isn't scattered.
20527                                 LightSrc    uint8
20528
20529                                 GndContent   bool
20530                                 Collides     bool
20531                                 Pointable    bool
20532                                 Diggable     bool
20533                                 Climbable    bool
20534                                 Replaceable  bool
20535                                 OnRightClick bool
20536
20537                                 DmgPerSec int32
20538
20539                                 LiquidType   LiquidType
20540                                 FlowingAlt   string
20541                                 SrcAlt       string
20542                                 Viscosity    uint8 // 0-7
20543                                 LiqRenewable bool
20544                                 FlowRange    uint8
20545                                 DrownDmg     uint8
20546                                 Floodable    bool
20547
20548                                 DrawBox, ColBox, SelBox NodeBox
20549
20550                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20551
20552                                 LegacyFaceDir bool
20553                                 LegacyMounted bool
20554
20555                                 DigPredict string
20556
20557                                 MaxLvl uint8
20558
20559                                 AlphaUse
20560                         }))(obj)).Translucent
20561                         switch n := read8(r); n {
20562                         case 0:
20563                                 *p = false
20564                         case 1:
20565                                 *p = true
20566                         default:
20567                                 chk(fmt.Errorf("invalid bool: %d", n))
20568                         }
20569                 }
20570                 {
20571                         p := &(*(*(struct {
20572                                 Param0 Content
20573
20574                                 Name   string
20575                                 Groups []Group
20576
20577                                 P1Type   Param1Type
20578                                 P2Type   Param2Type
20579                                 DrawType DrawType
20580
20581                                 Mesh  string
20582                                 Scale float32
20583                                 //mt:const uint8(6)
20584                                 Tiles        [6]TileDef
20585                                 OverlayTiles [6]TileDef
20586                                 //mt:const uint8(6)
20587                                 SpecialTiles [6]TileDef
20588
20589                                 Color   color.NRGBA
20590                                 Palette Texture
20591
20592                                 Waving       WaveType
20593                                 ConnectSides uint8
20594                                 ConnectTo    []Content
20595                                 InsideTint   color.NRGBA
20596                                 Level        uint8 // Must be < 128.
20597
20598                                 Translucent bool // Sunlight is scattered and becomes normal light.
20599                                 Transparent bool // Sunlight isn't scattered.
20600                                 LightSrc    uint8
20601
20602                                 GndContent   bool
20603                                 Collides     bool
20604                                 Pointable    bool
20605                                 Diggable     bool
20606                                 Climbable    bool
20607                                 Replaceable  bool
20608                                 OnRightClick bool
20609
20610                                 DmgPerSec int32
20611
20612                                 LiquidType   LiquidType
20613                                 FlowingAlt   string
20614                                 SrcAlt       string
20615                                 Viscosity    uint8 // 0-7
20616                                 LiqRenewable bool
20617                                 FlowRange    uint8
20618                                 DrownDmg     uint8
20619                                 Floodable    bool
20620
20621                                 DrawBox, ColBox, SelBox NodeBox
20622
20623                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20624
20625                                 LegacyFaceDir bool
20626                                 LegacyMounted bool
20627
20628                                 DigPredict string
20629
20630                                 MaxLvl uint8
20631
20632                                 AlphaUse
20633                         }))(obj)).Transparent
20634                         switch n := read8(r); n {
20635                         case 0:
20636                                 *p = false
20637                         case 1:
20638                                 *p = true
20639                         default:
20640                                 chk(fmt.Errorf("invalid bool: %d", n))
20641                         }
20642                 }
20643                 {
20644                         p := &(*(*(struct {
20645                                 Param0 Content
20646
20647                                 Name   string
20648                                 Groups []Group
20649
20650                                 P1Type   Param1Type
20651                                 P2Type   Param2Type
20652                                 DrawType DrawType
20653
20654                                 Mesh  string
20655                                 Scale float32
20656                                 //mt:const uint8(6)
20657                                 Tiles        [6]TileDef
20658                                 OverlayTiles [6]TileDef
20659                                 //mt:const uint8(6)
20660                                 SpecialTiles [6]TileDef
20661
20662                                 Color   color.NRGBA
20663                                 Palette Texture
20664
20665                                 Waving       WaveType
20666                                 ConnectSides uint8
20667                                 ConnectTo    []Content
20668                                 InsideTint   color.NRGBA
20669                                 Level        uint8 // Must be < 128.
20670
20671                                 Translucent bool // Sunlight is scattered and becomes normal light.
20672                                 Transparent bool // Sunlight isn't scattered.
20673                                 LightSrc    uint8
20674
20675                                 GndContent   bool
20676                                 Collides     bool
20677                                 Pointable    bool
20678                                 Diggable     bool
20679                                 Climbable    bool
20680                                 Replaceable  bool
20681                                 OnRightClick bool
20682
20683                                 DmgPerSec int32
20684
20685                                 LiquidType   LiquidType
20686                                 FlowingAlt   string
20687                                 SrcAlt       string
20688                                 Viscosity    uint8 // 0-7
20689                                 LiqRenewable bool
20690                                 FlowRange    uint8
20691                                 DrownDmg     uint8
20692                                 Floodable    bool
20693
20694                                 DrawBox, ColBox, SelBox NodeBox
20695
20696                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20697
20698                                 LegacyFaceDir bool
20699                                 LegacyMounted bool
20700
20701                                 DigPredict string
20702
20703                                 MaxLvl uint8
20704
20705                                 AlphaUse
20706                         }))(obj)).LightSrc
20707                         *p = read8(r)
20708                 }
20709                 {
20710                         p := &(*(*(struct {
20711                                 Param0 Content
20712
20713                                 Name   string
20714                                 Groups []Group
20715
20716                                 P1Type   Param1Type
20717                                 P2Type   Param2Type
20718                                 DrawType DrawType
20719
20720                                 Mesh  string
20721                                 Scale float32
20722                                 //mt:const uint8(6)
20723                                 Tiles        [6]TileDef
20724                                 OverlayTiles [6]TileDef
20725                                 //mt:const uint8(6)
20726                                 SpecialTiles [6]TileDef
20727
20728                                 Color   color.NRGBA
20729                                 Palette Texture
20730
20731                                 Waving       WaveType
20732                                 ConnectSides uint8
20733                                 ConnectTo    []Content
20734                                 InsideTint   color.NRGBA
20735                                 Level        uint8 // Must be < 128.
20736
20737                                 Translucent bool // Sunlight is scattered and becomes normal light.
20738                                 Transparent bool // Sunlight isn't scattered.
20739                                 LightSrc    uint8
20740
20741                                 GndContent   bool
20742                                 Collides     bool
20743                                 Pointable    bool
20744                                 Diggable     bool
20745                                 Climbable    bool
20746                                 Replaceable  bool
20747                                 OnRightClick bool
20748
20749                                 DmgPerSec int32
20750
20751                                 LiquidType   LiquidType
20752                                 FlowingAlt   string
20753                                 SrcAlt       string
20754                                 Viscosity    uint8 // 0-7
20755                                 LiqRenewable bool
20756                                 FlowRange    uint8
20757                                 DrownDmg     uint8
20758                                 Floodable    bool
20759
20760                                 DrawBox, ColBox, SelBox NodeBox
20761
20762                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20763
20764                                 LegacyFaceDir bool
20765                                 LegacyMounted bool
20766
20767                                 DigPredict string
20768
20769                                 MaxLvl uint8
20770
20771                                 AlphaUse
20772                         }))(obj)).GndContent
20773                         switch n := read8(r); n {
20774                         case 0:
20775                                 *p = false
20776                         case 1:
20777                                 *p = true
20778                         default:
20779                                 chk(fmt.Errorf("invalid bool: %d", n))
20780                         }
20781                 }
20782                 {
20783                         p := &(*(*(struct {
20784                                 Param0 Content
20785
20786                                 Name   string
20787                                 Groups []Group
20788
20789                                 P1Type   Param1Type
20790                                 P2Type   Param2Type
20791                                 DrawType DrawType
20792
20793                                 Mesh  string
20794                                 Scale float32
20795                                 //mt:const uint8(6)
20796                                 Tiles        [6]TileDef
20797                                 OverlayTiles [6]TileDef
20798                                 //mt:const uint8(6)
20799                                 SpecialTiles [6]TileDef
20800
20801                                 Color   color.NRGBA
20802                                 Palette Texture
20803
20804                                 Waving       WaveType
20805                                 ConnectSides uint8
20806                                 ConnectTo    []Content
20807                                 InsideTint   color.NRGBA
20808                                 Level        uint8 // Must be < 128.
20809
20810                                 Translucent bool // Sunlight is scattered and becomes normal light.
20811                                 Transparent bool // Sunlight isn't scattered.
20812                                 LightSrc    uint8
20813
20814                                 GndContent   bool
20815                                 Collides     bool
20816                                 Pointable    bool
20817                                 Diggable     bool
20818                                 Climbable    bool
20819                                 Replaceable  bool
20820                                 OnRightClick bool
20821
20822                                 DmgPerSec int32
20823
20824                                 LiquidType   LiquidType
20825                                 FlowingAlt   string
20826                                 SrcAlt       string
20827                                 Viscosity    uint8 // 0-7
20828                                 LiqRenewable bool
20829                                 FlowRange    uint8
20830                                 DrownDmg     uint8
20831                                 Floodable    bool
20832
20833                                 DrawBox, ColBox, SelBox NodeBox
20834
20835                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20836
20837                                 LegacyFaceDir bool
20838                                 LegacyMounted bool
20839
20840                                 DigPredict string
20841
20842                                 MaxLvl uint8
20843
20844                                 AlphaUse
20845                         }))(obj)).Collides
20846                         switch n := read8(r); n {
20847                         case 0:
20848                                 *p = false
20849                         case 1:
20850                                 *p = true
20851                         default:
20852                                 chk(fmt.Errorf("invalid bool: %d", n))
20853                         }
20854                 }
20855                 {
20856                         p := &(*(*(struct {
20857                                 Param0 Content
20858
20859                                 Name   string
20860                                 Groups []Group
20861
20862                                 P1Type   Param1Type
20863                                 P2Type   Param2Type
20864                                 DrawType DrawType
20865
20866                                 Mesh  string
20867                                 Scale float32
20868                                 //mt:const uint8(6)
20869                                 Tiles        [6]TileDef
20870                                 OverlayTiles [6]TileDef
20871                                 //mt:const uint8(6)
20872                                 SpecialTiles [6]TileDef
20873
20874                                 Color   color.NRGBA
20875                                 Palette Texture
20876
20877                                 Waving       WaveType
20878                                 ConnectSides uint8
20879                                 ConnectTo    []Content
20880                                 InsideTint   color.NRGBA
20881                                 Level        uint8 // Must be < 128.
20882
20883                                 Translucent bool // Sunlight is scattered and becomes normal light.
20884                                 Transparent bool // Sunlight isn't scattered.
20885                                 LightSrc    uint8
20886
20887                                 GndContent   bool
20888                                 Collides     bool
20889                                 Pointable    bool
20890                                 Diggable     bool
20891                                 Climbable    bool
20892                                 Replaceable  bool
20893                                 OnRightClick bool
20894
20895                                 DmgPerSec int32
20896
20897                                 LiquidType   LiquidType
20898                                 FlowingAlt   string
20899                                 SrcAlt       string
20900                                 Viscosity    uint8 // 0-7
20901                                 LiqRenewable bool
20902                                 FlowRange    uint8
20903                                 DrownDmg     uint8
20904                                 Floodable    bool
20905
20906                                 DrawBox, ColBox, SelBox NodeBox
20907
20908                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20909
20910                                 LegacyFaceDir bool
20911                                 LegacyMounted bool
20912
20913                                 DigPredict string
20914
20915                                 MaxLvl uint8
20916
20917                                 AlphaUse
20918                         }))(obj)).Pointable
20919                         switch n := read8(r); n {
20920                         case 0:
20921                                 *p = false
20922                         case 1:
20923                                 *p = true
20924                         default:
20925                                 chk(fmt.Errorf("invalid bool: %d", n))
20926                         }
20927                 }
20928                 {
20929                         p := &(*(*(struct {
20930                                 Param0 Content
20931
20932                                 Name   string
20933                                 Groups []Group
20934
20935                                 P1Type   Param1Type
20936                                 P2Type   Param2Type
20937                                 DrawType DrawType
20938
20939                                 Mesh  string
20940                                 Scale float32
20941                                 //mt:const uint8(6)
20942                                 Tiles        [6]TileDef
20943                                 OverlayTiles [6]TileDef
20944                                 //mt:const uint8(6)
20945                                 SpecialTiles [6]TileDef
20946
20947                                 Color   color.NRGBA
20948                                 Palette Texture
20949
20950                                 Waving       WaveType
20951                                 ConnectSides uint8
20952                                 ConnectTo    []Content
20953                                 InsideTint   color.NRGBA
20954                                 Level        uint8 // Must be < 128.
20955
20956                                 Translucent bool // Sunlight is scattered and becomes normal light.
20957                                 Transparent bool // Sunlight isn't scattered.
20958                                 LightSrc    uint8
20959
20960                                 GndContent   bool
20961                                 Collides     bool
20962                                 Pointable    bool
20963                                 Diggable     bool
20964                                 Climbable    bool
20965                                 Replaceable  bool
20966                                 OnRightClick bool
20967
20968                                 DmgPerSec int32
20969
20970                                 LiquidType   LiquidType
20971                                 FlowingAlt   string
20972                                 SrcAlt       string
20973                                 Viscosity    uint8 // 0-7
20974                                 LiqRenewable bool
20975                                 FlowRange    uint8
20976                                 DrownDmg     uint8
20977                                 Floodable    bool
20978
20979                                 DrawBox, ColBox, SelBox NodeBox
20980
20981                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20982
20983                                 LegacyFaceDir bool
20984                                 LegacyMounted bool
20985
20986                                 DigPredict string
20987
20988                                 MaxLvl uint8
20989
20990                                 AlphaUse
20991                         }))(obj)).Diggable
20992                         switch n := read8(r); n {
20993                         case 0:
20994                                 *p = false
20995                         case 1:
20996                                 *p = true
20997                         default:
20998                                 chk(fmt.Errorf("invalid bool: %d", n))
20999                         }
21000                 }
21001                 {
21002                         p := &(*(*(struct {
21003                                 Param0 Content
21004
21005                                 Name   string
21006                                 Groups []Group
21007
21008                                 P1Type   Param1Type
21009                                 P2Type   Param2Type
21010                                 DrawType DrawType
21011
21012                                 Mesh  string
21013                                 Scale float32
21014                                 //mt:const uint8(6)
21015                                 Tiles        [6]TileDef
21016                                 OverlayTiles [6]TileDef
21017                                 //mt:const uint8(6)
21018                                 SpecialTiles [6]TileDef
21019
21020                                 Color   color.NRGBA
21021                                 Palette Texture
21022
21023                                 Waving       WaveType
21024                                 ConnectSides uint8
21025                                 ConnectTo    []Content
21026                                 InsideTint   color.NRGBA
21027                                 Level        uint8 // Must be < 128.
21028
21029                                 Translucent bool // Sunlight is scattered and becomes normal light.
21030                                 Transparent bool // Sunlight isn't scattered.
21031                                 LightSrc    uint8
21032
21033                                 GndContent   bool
21034                                 Collides     bool
21035                                 Pointable    bool
21036                                 Diggable     bool
21037                                 Climbable    bool
21038                                 Replaceable  bool
21039                                 OnRightClick bool
21040
21041                                 DmgPerSec int32
21042
21043                                 LiquidType   LiquidType
21044                                 FlowingAlt   string
21045                                 SrcAlt       string
21046                                 Viscosity    uint8 // 0-7
21047                                 LiqRenewable bool
21048                                 FlowRange    uint8
21049                                 DrownDmg     uint8
21050                                 Floodable    bool
21051
21052                                 DrawBox, ColBox, SelBox NodeBox
21053
21054                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21055
21056                                 LegacyFaceDir bool
21057                                 LegacyMounted bool
21058
21059                                 DigPredict string
21060
21061                                 MaxLvl uint8
21062
21063                                 AlphaUse
21064                         }))(obj)).Climbable
21065                         switch n := read8(r); n {
21066                         case 0:
21067                                 *p = false
21068                         case 1:
21069                                 *p = true
21070                         default:
21071                                 chk(fmt.Errorf("invalid bool: %d", n))
21072                         }
21073                 }
21074                 {
21075                         p := &(*(*(struct {
21076                                 Param0 Content
21077
21078                                 Name   string
21079                                 Groups []Group
21080
21081                                 P1Type   Param1Type
21082                                 P2Type   Param2Type
21083                                 DrawType DrawType
21084
21085                                 Mesh  string
21086                                 Scale float32
21087                                 //mt:const uint8(6)
21088                                 Tiles        [6]TileDef
21089                                 OverlayTiles [6]TileDef
21090                                 //mt:const uint8(6)
21091                                 SpecialTiles [6]TileDef
21092
21093                                 Color   color.NRGBA
21094                                 Palette Texture
21095
21096                                 Waving       WaveType
21097                                 ConnectSides uint8
21098                                 ConnectTo    []Content
21099                                 InsideTint   color.NRGBA
21100                                 Level        uint8 // Must be < 128.
21101
21102                                 Translucent bool // Sunlight is scattered and becomes normal light.
21103                                 Transparent bool // Sunlight isn't scattered.
21104                                 LightSrc    uint8
21105
21106                                 GndContent   bool
21107                                 Collides     bool
21108                                 Pointable    bool
21109                                 Diggable     bool
21110                                 Climbable    bool
21111                                 Replaceable  bool
21112                                 OnRightClick bool
21113
21114                                 DmgPerSec int32
21115
21116                                 LiquidType   LiquidType
21117                                 FlowingAlt   string
21118                                 SrcAlt       string
21119                                 Viscosity    uint8 // 0-7
21120                                 LiqRenewable bool
21121                                 FlowRange    uint8
21122                                 DrownDmg     uint8
21123                                 Floodable    bool
21124
21125                                 DrawBox, ColBox, SelBox NodeBox
21126
21127                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21128
21129                                 LegacyFaceDir bool
21130                                 LegacyMounted bool
21131
21132                                 DigPredict string
21133
21134                                 MaxLvl uint8
21135
21136                                 AlphaUse
21137                         }))(obj)).Replaceable
21138                         switch n := read8(r); n {
21139                         case 0:
21140                                 *p = false
21141                         case 1:
21142                                 *p = true
21143                         default:
21144                                 chk(fmt.Errorf("invalid bool: %d", n))
21145                         }
21146                 }
21147                 {
21148                         p := &(*(*(struct {
21149                                 Param0 Content
21150
21151                                 Name   string
21152                                 Groups []Group
21153
21154                                 P1Type   Param1Type
21155                                 P2Type   Param2Type
21156                                 DrawType DrawType
21157
21158                                 Mesh  string
21159                                 Scale float32
21160                                 //mt:const uint8(6)
21161                                 Tiles        [6]TileDef
21162                                 OverlayTiles [6]TileDef
21163                                 //mt:const uint8(6)
21164                                 SpecialTiles [6]TileDef
21165
21166                                 Color   color.NRGBA
21167                                 Palette Texture
21168
21169                                 Waving       WaveType
21170                                 ConnectSides uint8
21171                                 ConnectTo    []Content
21172                                 InsideTint   color.NRGBA
21173                                 Level        uint8 // Must be < 128.
21174
21175                                 Translucent bool // Sunlight is scattered and becomes normal light.
21176                                 Transparent bool // Sunlight isn't scattered.
21177                                 LightSrc    uint8
21178
21179                                 GndContent   bool
21180                                 Collides     bool
21181                                 Pointable    bool
21182                                 Diggable     bool
21183                                 Climbable    bool
21184                                 Replaceable  bool
21185                                 OnRightClick bool
21186
21187                                 DmgPerSec int32
21188
21189                                 LiquidType   LiquidType
21190                                 FlowingAlt   string
21191                                 SrcAlt       string
21192                                 Viscosity    uint8 // 0-7
21193                                 LiqRenewable bool
21194                                 FlowRange    uint8
21195                                 DrownDmg     uint8
21196                                 Floodable    bool
21197
21198                                 DrawBox, ColBox, SelBox NodeBox
21199
21200                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21201
21202                                 LegacyFaceDir bool
21203                                 LegacyMounted bool
21204
21205                                 DigPredict string
21206
21207                                 MaxLvl uint8
21208
21209                                 AlphaUse
21210                         }))(obj)).OnRightClick
21211                         switch n := read8(r); n {
21212                         case 0:
21213                                 *p = false
21214                         case 1:
21215                                 *p = true
21216                         default:
21217                                 chk(fmt.Errorf("invalid bool: %d", n))
21218                         }
21219                 }
21220                 {
21221                         p := &(*(*(struct {
21222                                 Param0 Content
21223
21224                                 Name   string
21225                                 Groups []Group
21226
21227                                 P1Type   Param1Type
21228                                 P2Type   Param2Type
21229                                 DrawType DrawType
21230
21231                                 Mesh  string
21232                                 Scale float32
21233                                 //mt:const uint8(6)
21234                                 Tiles        [6]TileDef
21235                                 OverlayTiles [6]TileDef
21236                                 //mt:const uint8(6)
21237                                 SpecialTiles [6]TileDef
21238
21239                                 Color   color.NRGBA
21240                                 Palette Texture
21241
21242                                 Waving       WaveType
21243                                 ConnectSides uint8
21244                                 ConnectTo    []Content
21245                                 InsideTint   color.NRGBA
21246                                 Level        uint8 // Must be < 128.
21247
21248                                 Translucent bool // Sunlight is scattered and becomes normal light.
21249                                 Transparent bool // Sunlight isn't scattered.
21250                                 LightSrc    uint8
21251
21252                                 GndContent   bool
21253                                 Collides     bool
21254                                 Pointable    bool
21255                                 Diggable     bool
21256                                 Climbable    bool
21257                                 Replaceable  bool
21258                                 OnRightClick bool
21259
21260                                 DmgPerSec int32
21261
21262                                 LiquidType   LiquidType
21263                                 FlowingAlt   string
21264                                 SrcAlt       string
21265                                 Viscosity    uint8 // 0-7
21266                                 LiqRenewable bool
21267                                 FlowRange    uint8
21268                                 DrownDmg     uint8
21269                                 Floodable    bool
21270
21271                                 DrawBox, ColBox, SelBox NodeBox
21272
21273                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21274
21275                                 LegacyFaceDir bool
21276                                 LegacyMounted bool
21277
21278                                 DigPredict string
21279
21280                                 MaxLvl uint8
21281
21282                                 AlphaUse
21283                         }))(obj)).DmgPerSec
21284                         *p = int32(read32(r))
21285                 }
21286                 if err := pcall(func() {
21287                         ((*(*(struct {
21288                                 Param0 Content
21289
21290                                 Name   string
21291                                 Groups []Group
21292
21293                                 P1Type   Param1Type
21294                                 P2Type   Param2Type
21295                                 DrawType DrawType
21296
21297                                 Mesh  string
21298                                 Scale float32
21299                                 //mt:const uint8(6)
21300                                 Tiles        [6]TileDef
21301                                 OverlayTiles [6]TileDef
21302                                 //mt:const uint8(6)
21303                                 SpecialTiles [6]TileDef
21304
21305                                 Color   color.NRGBA
21306                                 Palette Texture
21307
21308                                 Waving       WaveType
21309                                 ConnectSides uint8
21310                                 ConnectTo    []Content
21311                                 InsideTint   color.NRGBA
21312                                 Level        uint8 // Must be < 128.
21313
21314                                 Translucent bool // Sunlight is scattered and becomes normal light.
21315                                 Transparent bool // Sunlight isn't scattered.
21316                                 LightSrc    uint8
21317
21318                                 GndContent   bool
21319                                 Collides     bool
21320                                 Pointable    bool
21321                                 Diggable     bool
21322                                 Climbable    bool
21323                                 Replaceable  bool
21324                                 OnRightClick bool
21325
21326                                 DmgPerSec int32
21327
21328                                 LiquidType   LiquidType
21329                                 FlowingAlt   string
21330                                 SrcAlt       string
21331                                 Viscosity    uint8 // 0-7
21332                                 LiqRenewable bool
21333                                 FlowRange    uint8
21334                                 DrownDmg     uint8
21335                                 Floodable    bool
21336
21337                                 DrawBox, ColBox, SelBox NodeBox
21338
21339                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21340
21341                                 LegacyFaceDir bool
21342                                 LegacyMounted bool
21343
21344                                 DigPredict string
21345
21346                                 MaxLvl uint8
21347
21348                                 AlphaUse
21349                         }))(obj)).LiquidType).deserialize(r)
21350                 }); err != nil {
21351                         if err == io.EOF {
21352                                 chk(io.EOF)
21353                         }
21354                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
21355                 }
21356                 var local263 []uint8
21357                 var local264 uint16
21358                 {
21359                         p := &local264
21360                         *p = read16(r)
21361                 }
21362                 (local263) = make([]uint8, local264)
21363                 {
21364                         _, err := io.ReadFull(r, (local263)[:])
21365                         chk(err)
21366                 }
21367                 ((*(*(struct {
21368                         Param0 Content
21369
21370                         Name   string
21371                         Groups []Group
21372
21373                         P1Type   Param1Type
21374                         P2Type   Param2Type
21375                         DrawType DrawType
21376
21377                         Mesh  string
21378                         Scale float32
21379                         //mt:const uint8(6)
21380                         Tiles        [6]TileDef
21381                         OverlayTiles [6]TileDef
21382                         //mt:const uint8(6)
21383                         SpecialTiles [6]TileDef
21384
21385                         Color   color.NRGBA
21386                         Palette Texture
21387
21388                         Waving       WaveType
21389                         ConnectSides uint8
21390                         ConnectTo    []Content
21391                         InsideTint   color.NRGBA
21392                         Level        uint8 // Must be < 128.
21393
21394                         Translucent bool // Sunlight is scattered and becomes normal light.
21395                         Transparent bool // Sunlight isn't scattered.
21396                         LightSrc    uint8
21397
21398                         GndContent   bool
21399                         Collides     bool
21400                         Pointable    bool
21401                         Diggable     bool
21402                         Climbable    bool
21403                         Replaceable  bool
21404                         OnRightClick bool
21405
21406                         DmgPerSec int32
21407
21408                         LiquidType   LiquidType
21409                         FlowingAlt   string
21410                         SrcAlt       string
21411                         Viscosity    uint8 // 0-7
21412                         LiqRenewable bool
21413                         FlowRange    uint8
21414                         DrownDmg     uint8
21415                         Floodable    bool
21416
21417                         DrawBox, ColBox, SelBox NodeBox
21418
21419                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21420
21421                         LegacyFaceDir bool
21422                         LegacyMounted bool
21423
21424                         DigPredict string
21425
21426                         MaxLvl uint8
21427
21428                         AlphaUse
21429                 }))(obj)).FlowingAlt) = string(local263)
21430                 var local265 []uint8
21431                 var local266 uint16
21432                 {
21433                         p := &local266
21434                         *p = read16(r)
21435                 }
21436                 (local265) = make([]uint8, local266)
21437                 {
21438                         _, err := io.ReadFull(r, (local265)[:])
21439                         chk(err)
21440                 }
21441                 ((*(*(struct {
21442                         Param0 Content
21443
21444                         Name   string
21445                         Groups []Group
21446
21447                         P1Type   Param1Type
21448                         P2Type   Param2Type
21449                         DrawType DrawType
21450
21451                         Mesh  string
21452                         Scale float32
21453                         //mt:const uint8(6)
21454                         Tiles        [6]TileDef
21455                         OverlayTiles [6]TileDef
21456                         //mt:const uint8(6)
21457                         SpecialTiles [6]TileDef
21458
21459                         Color   color.NRGBA
21460                         Palette Texture
21461
21462                         Waving       WaveType
21463                         ConnectSides uint8
21464                         ConnectTo    []Content
21465                         InsideTint   color.NRGBA
21466                         Level        uint8 // Must be < 128.
21467
21468                         Translucent bool // Sunlight is scattered and becomes normal light.
21469                         Transparent bool // Sunlight isn't scattered.
21470                         LightSrc    uint8
21471
21472                         GndContent   bool
21473                         Collides     bool
21474                         Pointable    bool
21475                         Diggable     bool
21476                         Climbable    bool
21477                         Replaceable  bool
21478                         OnRightClick bool
21479
21480                         DmgPerSec int32
21481
21482                         LiquidType   LiquidType
21483                         FlowingAlt   string
21484                         SrcAlt       string
21485                         Viscosity    uint8 // 0-7
21486                         LiqRenewable bool
21487                         FlowRange    uint8
21488                         DrownDmg     uint8
21489                         Floodable    bool
21490
21491                         DrawBox, ColBox, SelBox NodeBox
21492
21493                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21494
21495                         LegacyFaceDir bool
21496                         LegacyMounted bool
21497
21498                         DigPredict string
21499
21500                         MaxLvl uint8
21501
21502                         AlphaUse
21503                 }))(obj)).SrcAlt) = string(local265)
21504                 {
21505                         p := &(*(*(struct {
21506                                 Param0 Content
21507
21508                                 Name   string
21509                                 Groups []Group
21510
21511                                 P1Type   Param1Type
21512                                 P2Type   Param2Type
21513                                 DrawType DrawType
21514
21515                                 Mesh  string
21516                                 Scale float32
21517                                 //mt:const uint8(6)
21518                                 Tiles        [6]TileDef
21519                                 OverlayTiles [6]TileDef
21520                                 //mt:const uint8(6)
21521                                 SpecialTiles [6]TileDef
21522
21523                                 Color   color.NRGBA
21524                                 Palette Texture
21525
21526                                 Waving       WaveType
21527                                 ConnectSides uint8
21528                                 ConnectTo    []Content
21529                                 InsideTint   color.NRGBA
21530                                 Level        uint8 // Must be < 128.
21531
21532                                 Translucent bool // Sunlight is scattered and becomes normal light.
21533                                 Transparent bool // Sunlight isn't scattered.
21534                                 LightSrc    uint8
21535
21536                                 GndContent   bool
21537                                 Collides     bool
21538                                 Pointable    bool
21539                                 Diggable     bool
21540                                 Climbable    bool
21541                                 Replaceable  bool
21542                                 OnRightClick bool
21543
21544                                 DmgPerSec int32
21545
21546                                 LiquidType   LiquidType
21547                                 FlowingAlt   string
21548                                 SrcAlt       string
21549                                 Viscosity    uint8 // 0-7
21550                                 LiqRenewable bool
21551                                 FlowRange    uint8
21552                                 DrownDmg     uint8
21553                                 Floodable    bool
21554
21555                                 DrawBox, ColBox, SelBox NodeBox
21556
21557                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21558
21559                                 LegacyFaceDir bool
21560                                 LegacyMounted bool
21561
21562                                 DigPredict string
21563
21564                                 MaxLvl uint8
21565
21566                                 AlphaUse
21567                         }))(obj)).Viscosity
21568                         *p = read8(r)
21569                 }
21570                 {
21571                         p := &(*(*(struct {
21572                                 Param0 Content
21573
21574                                 Name   string
21575                                 Groups []Group
21576
21577                                 P1Type   Param1Type
21578                                 P2Type   Param2Type
21579                                 DrawType DrawType
21580
21581                                 Mesh  string
21582                                 Scale float32
21583                                 //mt:const uint8(6)
21584                                 Tiles        [6]TileDef
21585                                 OverlayTiles [6]TileDef
21586                                 //mt:const uint8(6)
21587                                 SpecialTiles [6]TileDef
21588
21589                                 Color   color.NRGBA
21590                                 Palette Texture
21591
21592                                 Waving       WaveType
21593                                 ConnectSides uint8
21594                                 ConnectTo    []Content
21595                                 InsideTint   color.NRGBA
21596                                 Level        uint8 // Must be < 128.
21597
21598                                 Translucent bool // Sunlight is scattered and becomes normal light.
21599                                 Transparent bool // Sunlight isn't scattered.
21600                                 LightSrc    uint8
21601
21602                                 GndContent   bool
21603                                 Collides     bool
21604                                 Pointable    bool
21605                                 Diggable     bool
21606                                 Climbable    bool
21607                                 Replaceable  bool
21608                                 OnRightClick bool
21609
21610                                 DmgPerSec int32
21611
21612                                 LiquidType   LiquidType
21613                                 FlowingAlt   string
21614                                 SrcAlt       string
21615                                 Viscosity    uint8 // 0-7
21616                                 LiqRenewable bool
21617                                 FlowRange    uint8
21618                                 DrownDmg     uint8
21619                                 Floodable    bool
21620
21621                                 DrawBox, ColBox, SelBox NodeBox
21622
21623                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21624
21625                                 LegacyFaceDir bool
21626                                 LegacyMounted bool
21627
21628                                 DigPredict string
21629
21630                                 MaxLvl uint8
21631
21632                                 AlphaUse
21633                         }))(obj)).LiqRenewable
21634                         switch n := read8(r); n {
21635                         case 0:
21636                                 *p = false
21637                         case 1:
21638                                 *p = true
21639                         default:
21640                                 chk(fmt.Errorf("invalid bool: %d", n))
21641                         }
21642                 }
21643                 {
21644                         p := &(*(*(struct {
21645                                 Param0 Content
21646
21647                                 Name   string
21648                                 Groups []Group
21649
21650                                 P1Type   Param1Type
21651                                 P2Type   Param2Type
21652                                 DrawType DrawType
21653
21654                                 Mesh  string
21655                                 Scale float32
21656                                 //mt:const uint8(6)
21657                                 Tiles        [6]TileDef
21658                                 OverlayTiles [6]TileDef
21659                                 //mt:const uint8(6)
21660                                 SpecialTiles [6]TileDef
21661
21662                                 Color   color.NRGBA
21663                                 Palette Texture
21664
21665                                 Waving       WaveType
21666                                 ConnectSides uint8
21667                                 ConnectTo    []Content
21668                                 InsideTint   color.NRGBA
21669                                 Level        uint8 // Must be < 128.
21670
21671                                 Translucent bool // Sunlight is scattered and becomes normal light.
21672                                 Transparent bool // Sunlight isn't scattered.
21673                                 LightSrc    uint8
21674
21675                                 GndContent   bool
21676                                 Collides     bool
21677                                 Pointable    bool
21678                                 Diggable     bool
21679                                 Climbable    bool
21680                                 Replaceable  bool
21681                                 OnRightClick bool
21682
21683                                 DmgPerSec int32
21684
21685                                 LiquidType   LiquidType
21686                                 FlowingAlt   string
21687                                 SrcAlt       string
21688                                 Viscosity    uint8 // 0-7
21689                                 LiqRenewable bool
21690                                 FlowRange    uint8
21691                                 DrownDmg     uint8
21692                                 Floodable    bool
21693
21694                                 DrawBox, ColBox, SelBox NodeBox
21695
21696                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21697
21698                                 LegacyFaceDir bool
21699                                 LegacyMounted bool
21700
21701                                 DigPredict string
21702
21703                                 MaxLvl uint8
21704
21705                                 AlphaUse
21706                         }))(obj)).FlowRange
21707                         *p = read8(r)
21708                 }
21709                 {
21710                         p := &(*(*(struct {
21711                                 Param0 Content
21712
21713                                 Name   string
21714                                 Groups []Group
21715
21716                                 P1Type   Param1Type
21717                                 P2Type   Param2Type
21718                                 DrawType DrawType
21719
21720                                 Mesh  string
21721                                 Scale float32
21722                                 //mt:const uint8(6)
21723                                 Tiles        [6]TileDef
21724                                 OverlayTiles [6]TileDef
21725                                 //mt:const uint8(6)
21726                                 SpecialTiles [6]TileDef
21727
21728                                 Color   color.NRGBA
21729                                 Palette Texture
21730
21731                                 Waving       WaveType
21732                                 ConnectSides uint8
21733                                 ConnectTo    []Content
21734                                 InsideTint   color.NRGBA
21735                                 Level        uint8 // Must be < 128.
21736
21737                                 Translucent bool // Sunlight is scattered and becomes normal light.
21738                                 Transparent bool // Sunlight isn't scattered.
21739                                 LightSrc    uint8
21740
21741                                 GndContent   bool
21742                                 Collides     bool
21743                                 Pointable    bool
21744                                 Diggable     bool
21745                                 Climbable    bool
21746                                 Replaceable  bool
21747                                 OnRightClick bool
21748
21749                                 DmgPerSec int32
21750
21751                                 LiquidType   LiquidType
21752                                 FlowingAlt   string
21753                                 SrcAlt       string
21754                                 Viscosity    uint8 // 0-7
21755                                 LiqRenewable bool
21756                                 FlowRange    uint8
21757                                 DrownDmg     uint8
21758                                 Floodable    bool
21759
21760                                 DrawBox, ColBox, SelBox NodeBox
21761
21762                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21763
21764                                 LegacyFaceDir bool
21765                                 LegacyMounted bool
21766
21767                                 DigPredict string
21768
21769                                 MaxLvl uint8
21770
21771                                 AlphaUse
21772                         }))(obj)).DrownDmg
21773                         *p = read8(r)
21774                 }
21775                 {
21776                         p := &(*(*(struct {
21777                                 Param0 Content
21778
21779                                 Name   string
21780                                 Groups []Group
21781
21782                                 P1Type   Param1Type
21783                                 P2Type   Param2Type
21784                                 DrawType DrawType
21785
21786                                 Mesh  string
21787                                 Scale float32
21788                                 //mt:const uint8(6)
21789                                 Tiles        [6]TileDef
21790                                 OverlayTiles [6]TileDef
21791                                 //mt:const uint8(6)
21792                                 SpecialTiles [6]TileDef
21793
21794                                 Color   color.NRGBA
21795                                 Palette Texture
21796
21797                                 Waving       WaveType
21798                                 ConnectSides uint8
21799                                 ConnectTo    []Content
21800                                 InsideTint   color.NRGBA
21801                                 Level        uint8 // Must be < 128.
21802
21803                                 Translucent bool // Sunlight is scattered and becomes normal light.
21804                                 Transparent bool // Sunlight isn't scattered.
21805                                 LightSrc    uint8
21806
21807                                 GndContent   bool
21808                                 Collides     bool
21809                                 Pointable    bool
21810                                 Diggable     bool
21811                                 Climbable    bool
21812                                 Replaceable  bool
21813                                 OnRightClick bool
21814
21815                                 DmgPerSec int32
21816
21817                                 LiquidType   LiquidType
21818                                 FlowingAlt   string
21819                                 SrcAlt       string
21820                                 Viscosity    uint8 // 0-7
21821                                 LiqRenewable bool
21822                                 FlowRange    uint8
21823                                 DrownDmg     uint8
21824                                 Floodable    bool
21825
21826                                 DrawBox, ColBox, SelBox NodeBox
21827
21828                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21829
21830                                 LegacyFaceDir bool
21831                                 LegacyMounted bool
21832
21833                                 DigPredict string
21834
21835                                 MaxLvl uint8
21836
21837                                 AlphaUse
21838                         }))(obj)).Floodable
21839                         switch n := read8(r); n {
21840                         case 0:
21841                                 *p = false
21842                         case 1:
21843                                 *p = true
21844                         default:
21845                                 chk(fmt.Errorf("invalid bool: %d", n))
21846                         }
21847                 }
21848                 if err := pcall(func() {
21849                         ((*(*(struct {
21850                                 Param0 Content
21851
21852                                 Name   string
21853                                 Groups []Group
21854
21855                                 P1Type   Param1Type
21856                                 P2Type   Param2Type
21857                                 DrawType DrawType
21858
21859                                 Mesh  string
21860                                 Scale float32
21861                                 //mt:const uint8(6)
21862                                 Tiles        [6]TileDef
21863                                 OverlayTiles [6]TileDef
21864                                 //mt:const uint8(6)
21865                                 SpecialTiles [6]TileDef
21866
21867                                 Color   color.NRGBA
21868                                 Palette Texture
21869
21870                                 Waving       WaveType
21871                                 ConnectSides uint8
21872                                 ConnectTo    []Content
21873                                 InsideTint   color.NRGBA
21874                                 Level        uint8 // Must be < 128.
21875
21876                                 Translucent bool // Sunlight is scattered and becomes normal light.
21877                                 Transparent bool // Sunlight isn't scattered.
21878                                 LightSrc    uint8
21879
21880                                 GndContent   bool
21881                                 Collides     bool
21882                                 Pointable    bool
21883                                 Diggable     bool
21884                                 Climbable    bool
21885                                 Replaceable  bool
21886                                 OnRightClick bool
21887
21888                                 DmgPerSec int32
21889
21890                                 LiquidType   LiquidType
21891                                 FlowingAlt   string
21892                                 SrcAlt       string
21893                                 Viscosity    uint8 // 0-7
21894                                 LiqRenewable bool
21895                                 FlowRange    uint8
21896                                 DrownDmg     uint8
21897                                 Floodable    bool
21898
21899                                 DrawBox, ColBox, SelBox NodeBox
21900
21901                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21902
21903                                 LegacyFaceDir bool
21904                                 LegacyMounted bool
21905
21906                                 DigPredict string
21907
21908                                 MaxLvl uint8
21909
21910                                 AlphaUse
21911                         }))(obj)).DrawBox).deserialize(r)
21912                 }); err != nil {
21913                         if err == io.EOF {
21914                                 chk(io.EOF)
21915                         }
21916                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
21917                 }
21918                 if err := pcall(func() {
21919                         ((*(*(struct {
21920                                 Param0 Content
21921
21922                                 Name   string
21923                                 Groups []Group
21924
21925                                 P1Type   Param1Type
21926                                 P2Type   Param2Type
21927                                 DrawType DrawType
21928
21929                                 Mesh  string
21930                                 Scale float32
21931                                 //mt:const uint8(6)
21932                                 Tiles        [6]TileDef
21933                                 OverlayTiles [6]TileDef
21934                                 //mt:const uint8(6)
21935                                 SpecialTiles [6]TileDef
21936
21937                                 Color   color.NRGBA
21938                                 Palette Texture
21939
21940                                 Waving       WaveType
21941                                 ConnectSides uint8
21942                                 ConnectTo    []Content
21943                                 InsideTint   color.NRGBA
21944                                 Level        uint8 // Must be < 128.
21945
21946                                 Translucent bool // Sunlight is scattered and becomes normal light.
21947                                 Transparent bool // Sunlight isn't scattered.
21948                                 LightSrc    uint8
21949
21950                                 GndContent   bool
21951                                 Collides     bool
21952                                 Pointable    bool
21953                                 Diggable     bool
21954                                 Climbable    bool
21955                                 Replaceable  bool
21956                                 OnRightClick bool
21957
21958                                 DmgPerSec int32
21959
21960                                 LiquidType   LiquidType
21961                                 FlowingAlt   string
21962                                 SrcAlt       string
21963                                 Viscosity    uint8 // 0-7
21964                                 LiqRenewable bool
21965                                 FlowRange    uint8
21966                                 DrownDmg     uint8
21967                                 Floodable    bool
21968
21969                                 DrawBox, ColBox, SelBox NodeBox
21970
21971                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21972
21973                                 LegacyFaceDir bool
21974                                 LegacyMounted bool
21975
21976                                 DigPredict string
21977
21978                                 MaxLvl uint8
21979
21980                                 AlphaUse
21981                         }))(obj)).ColBox).deserialize(r)
21982                 }); err != nil {
21983                         if err == io.EOF {
21984                                 chk(io.EOF)
21985                         }
21986                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
21987                 }
21988                 if err := pcall(func() {
21989                         ((*(*(struct {
21990                                 Param0 Content
21991
21992                                 Name   string
21993                                 Groups []Group
21994
21995                                 P1Type   Param1Type
21996                                 P2Type   Param2Type
21997                                 DrawType DrawType
21998
21999                                 Mesh  string
22000                                 Scale float32
22001                                 //mt:const uint8(6)
22002                                 Tiles        [6]TileDef
22003                                 OverlayTiles [6]TileDef
22004                                 //mt:const uint8(6)
22005                                 SpecialTiles [6]TileDef
22006
22007                                 Color   color.NRGBA
22008                                 Palette Texture
22009
22010                                 Waving       WaveType
22011                                 ConnectSides uint8
22012                                 ConnectTo    []Content
22013                                 InsideTint   color.NRGBA
22014                                 Level        uint8 // Must be < 128.
22015
22016                                 Translucent bool // Sunlight is scattered and becomes normal light.
22017                                 Transparent bool // Sunlight isn't scattered.
22018                                 LightSrc    uint8
22019
22020                                 GndContent   bool
22021                                 Collides     bool
22022                                 Pointable    bool
22023                                 Diggable     bool
22024                                 Climbable    bool
22025                                 Replaceable  bool
22026                                 OnRightClick bool
22027
22028                                 DmgPerSec int32
22029
22030                                 LiquidType   LiquidType
22031                                 FlowingAlt   string
22032                                 SrcAlt       string
22033                                 Viscosity    uint8 // 0-7
22034                                 LiqRenewable bool
22035                                 FlowRange    uint8
22036                                 DrownDmg     uint8
22037                                 Floodable    bool
22038
22039                                 DrawBox, ColBox, SelBox NodeBox
22040
22041                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22042
22043                                 LegacyFaceDir bool
22044                                 LegacyMounted bool
22045
22046                                 DigPredict string
22047
22048                                 MaxLvl uint8
22049
22050                                 AlphaUse
22051                         }))(obj)).SelBox).deserialize(r)
22052                 }); err != nil {
22053                         if err == io.EOF {
22054                                 chk(io.EOF)
22055                         }
22056                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22057                 }
22058                 if err := pcall(func() {
22059                         ((*(*(struct {
22060                                 Param0 Content
22061
22062                                 Name   string
22063                                 Groups []Group
22064
22065                                 P1Type   Param1Type
22066                                 P2Type   Param2Type
22067                                 DrawType DrawType
22068
22069                                 Mesh  string
22070                                 Scale float32
22071                                 //mt:const uint8(6)
22072                                 Tiles        [6]TileDef
22073                                 OverlayTiles [6]TileDef
22074                                 //mt:const uint8(6)
22075                                 SpecialTiles [6]TileDef
22076
22077                                 Color   color.NRGBA
22078                                 Palette Texture
22079
22080                                 Waving       WaveType
22081                                 ConnectSides uint8
22082                                 ConnectTo    []Content
22083                                 InsideTint   color.NRGBA
22084                                 Level        uint8 // Must be < 128.
22085
22086                                 Translucent bool // Sunlight is scattered and becomes normal light.
22087                                 Transparent bool // Sunlight isn't scattered.
22088                                 LightSrc    uint8
22089
22090                                 GndContent   bool
22091                                 Collides     bool
22092                                 Pointable    bool
22093                                 Diggable     bool
22094                                 Climbable    bool
22095                                 Replaceable  bool
22096                                 OnRightClick bool
22097
22098                                 DmgPerSec int32
22099
22100                                 LiquidType   LiquidType
22101                                 FlowingAlt   string
22102                                 SrcAlt       string
22103                                 Viscosity    uint8 // 0-7
22104                                 LiqRenewable bool
22105                                 FlowRange    uint8
22106                                 DrownDmg     uint8
22107                                 Floodable    bool
22108
22109                                 DrawBox, ColBox, SelBox NodeBox
22110
22111                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22112
22113                                 LegacyFaceDir bool
22114                                 LegacyMounted bool
22115
22116                                 DigPredict string
22117
22118                                 MaxLvl uint8
22119
22120                                 AlphaUse
22121                         }))(obj)).FootstepSnd).deserialize(r)
22122                 }); err != nil {
22123                         if err == io.EOF {
22124                                 chk(io.EOF)
22125                         }
22126                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22127                 }
22128                 if err := pcall(func() {
22129                         ((*(*(struct {
22130                                 Param0 Content
22131
22132                                 Name   string
22133                                 Groups []Group
22134
22135                                 P1Type   Param1Type
22136                                 P2Type   Param2Type
22137                                 DrawType DrawType
22138
22139                                 Mesh  string
22140                                 Scale float32
22141                                 //mt:const uint8(6)
22142                                 Tiles        [6]TileDef
22143                                 OverlayTiles [6]TileDef
22144                                 //mt:const uint8(6)
22145                                 SpecialTiles [6]TileDef
22146
22147                                 Color   color.NRGBA
22148                                 Palette Texture
22149
22150                                 Waving       WaveType
22151                                 ConnectSides uint8
22152                                 ConnectTo    []Content
22153                                 InsideTint   color.NRGBA
22154                                 Level        uint8 // Must be < 128.
22155
22156                                 Translucent bool // Sunlight is scattered and becomes normal light.
22157                                 Transparent bool // Sunlight isn't scattered.
22158                                 LightSrc    uint8
22159
22160                                 GndContent   bool
22161                                 Collides     bool
22162                                 Pointable    bool
22163                                 Diggable     bool
22164                                 Climbable    bool
22165                                 Replaceable  bool
22166                                 OnRightClick bool
22167
22168                                 DmgPerSec int32
22169
22170                                 LiquidType   LiquidType
22171                                 FlowingAlt   string
22172                                 SrcAlt       string
22173                                 Viscosity    uint8 // 0-7
22174                                 LiqRenewable bool
22175                                 FlowRange    uint8
22176                                 DrownDmg     uint8
22177                                 Floodable    bool
22178
22179                                 DrawBox, ColBox, SelBox NodeBox
22180
22181                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22182
22183                                 LegacyFaceDir bool
22184                                 LegacyMounted bool
22185
22186                                 DigPredict string
22187
22188                                 MaxLvl uint8
22189
22190                                 AlphaUse
22191                         }))(obj)).DiggingSnd).deserialize(r)
22192                 }); err != nil {
22193                         if err == io.EOF {
22194                                 chk(io.EOF)
22195                         }
22196                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22197                 }
22198                 if err := pcall(func() {
22199                         ((*(*(struct {
22200                                 Param0 Content
22201
22202                                 Name   string
22203                                 Groups []Group
22204
22205                                 P1Type   Param1Type
22206                                 P2Type   Param2Type
22207                                 DrawType DrawType
22208
22209                                 Mesh  string
22210                                 Scale float32
22211                                 //mt:const uint8(6)
22212                                 Tiles        [6]TileDef
22213                                 OverlayTiles [6]TileDef
22214                                 //mt:const uint8(6)
22215                                 SpecialTiles [6]TileDef
22216
22217                                 Color   color.NRGBA
22218                                 Palette Texture
22219
22220                                 Waving       WaveType
22221                                 ConnectSides uint8
22222                                 ConnectTo    []Content
22223                                 InsideTint   color.NRGBA
22224                                 Level        uint8 // Must be < 128.
22225
22226                                 Translucent bool // Sunlight is scattered and becomes normal light.
22227                                 Transparent bool // Sunlight isn't scattered.
22228                                 LightSrc    uint8
22229
22230                                 GndContent   bool
22231                                 Collides     bool
22232                                 Pointable    bool
22233                                 Diggable     bool
22234                                 Climbable    bool
22235                                 Replaceable  bool
22236                                 OnRightClick bool
22237
22238                                 DmgPerSec int32
22239
22240                                 LiquidType   LiquidType
22241                                 FlowingAlt   string
22242                                 SrcAlt       string
22243                                 Viscosity    uint8 // 0-7
22244                                 LiqRenewable bool
22245                                 FlowRange    uint8
22246                                 DrownDmg     uint8
22247                                 Floodable    bool
22248
22249                                 DrawBox, ColBox, SelBox NodeBox
22250
22251                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22252
22253                                 LegacyFaceDir bool
22254                                 LegacyMounted bool
22255
22256                                 DigPredict string
22257
22258                                 MaxLvl uint8
22259
22260                                 AlphaUse
22261                         }))(obj)).DugSnd).deserialize(r)
22262                 }); err != nil {
22263                         if err == io.EOF {
22264                                 chk(io.EOF)
22265                         }
22266                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22267                 }
22268                 {
22269                         p := &(*(*(struct {
22270                                 Param0 Content
22271
22272                                 Name   string
22273                                 Groups []Group
22274
22275                                 P1Type   Param1Type
22276                                 P2Type   Param2Type
22277                                 DrawType DrawType
22278
22279                                 Mesh  string
22280                                 Scale float32
22281                                 //mt:const uint8(6)
22282                                 Tiles        [6]TileDef
22283                                 OverlayTiles [6]TileDef
22284                                 //mt:const uint8(6)
22285                                 SpecialTiles [6]TileDef
22286
22287                                 Color   color.NRGBA
22288                                 Palette Texture
22289
22290                                 Waving       WaveType
22291                                 ConnectSides uint8
22292                                 ConnectTo    []Content
22293                                 InsideTint   color.NRGBA
22294                                 Level        uint8 // Must be < 128.
22295
22296                                 Translucent bool // Sunlight is scattered and becomes normal light.
22297                                 Transparent bool // Sunlight isn't scattered.
22298                                 LightSrc    uint8
22299
22300                                 GndContent   bool
22301                                 Collides     bool
22302                                 Pointable    bool
22303                                 Diggable     bool
22304                                 Climbable    bool
22305                                 Replaceable  bool
22306                                 OnRightClick bool
22307
22308                                 DmgPerSec int32
22309
22310                                 LiquidType   LiquidType
22311                                 FlowingAlt   string
22312                                 SrcAlt       string
22313                                 Viscosity    uint8 // 0-7
22314                                 LiqRenewable bool
22315                                 FlowRange    uint8
22316                                 DrownDmg     uint8
22317                                 Floodable    bool
22318
22319                                 DrawBox, ColBox, SelBox NodeBox
22320
22321                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22322
22323                                 LegacyFaceDir bool
22324                                 LegacyMounted bool
22325
22326                                 DigPredict string
22327
22328                                 MaxLvl uint8
22329
22330                                 AlphaUse
22331                         }))(obj)).LegacyFaceDir
22332                         switch n := read8(r); n {
22333                         case 0:
22334                                 *p = false
22335                         case 1:
22336                                 *p = true
22337                         default:
22338                                 chk(fmt.Errorf("invalid bool: %d", n))
22339                         }
22340                 }
22341                 {
22342                         p := &(*(*(struct {
22343                                 Param0 Content
22344
22345                                 Name   string
22346                                 Groups []Group
22347
22348                                 P1Type   Param1Type
22349                                 P2Type   Param2Type
22350                                 DrawType DrawType
22351
22352                                 Mesh  string
22353                                 Scale float32
22354                                 //mt:const uint8(6)
22355                                 Tiles        [6]TileDef
22356                                 OverlayTiles [6]TileDef
22357                                 //mt:const uint8(6)
22358                                 SpecialTiles [6]TileDef
22359
22360                                 Color   color.NRGBA
22361                                 Palette Texture
22362
22363                                 Waving       WaveType
22364                                 ConnectSides uint8
22365                                 ConnectTo    []Content
22366                                 InsideTint   color.NRGBA
22367                                 Level        uint8 // Must be < 128.
22368
22369                                 Translucent bool // Sunlight is scattered and becomes normal light.
22370                                 Transparent bool // Sunlight isn't scattered.
22371                                 LightSrc    uint8
22372
22373                                 GndContent   bool
22374                                 Collides     bool
22375                                 Pointable    bool
22376                                 Diggable     bool
22377                                 Climbable    bool
22378                                 Replaceable  bool
22379                                 OnRightClick bool
22380
22381                                 DmgPerSec int32
22382
22383                                 LiquidType   LiquidType
22384                                 FlowingAlt   string
22385                                 SrcAlt       string
22386                                 Viscosity    uint8 // 0-7
22387                                 LiqRenewable bool
22388                                 FlowRange    uint8
22389                                 DrownDmg     uint8
22390                                 Floodable    bool
22391
22392                                 DrawBox, ColBox, SelBox NodeBox
22393
22394                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22395
22396                                 LegacyFaceDir bool
22397                                 LegacyMounted bool
22398
22399                                 DigPredict string
22400
22401                                 MaxLvl uint8
22402
22403                                 AlphaUse
22404                         }))(obj)).LegacyMounted
22405                         switch n := read8(r); n {
22406                         case 0:
22407                                 *p = false
22408                         case 1:
22409                                 *p = true
22410                         default:
22411                                 chk(fmt.Errorf("invalid bool: %d", n))
22412                         }
22413                 }
22414                 var local267 []uint8
22415                 var local268 uint16
22416                 {
22417                         p := &local268
22418                         *p = read16(r)
22419                 }
22420                 (local267) = make([]uint8, local268)
22421                 {
22422                         _, err := io.ReadFull(r, (local267)[:])
22423                         chk(err)
22424                 }
22425                 ((*(*(struct {
22426                         Param0 Content
22427
22428                         Name   string
22429                         Groups []Group
22430
22431                         P1Type   Param1Type
22432                         P2Type   Param2Type
22433                         DrawType DrawType
22434
22435                         Mesh  string
22436                         Scale float32
22437                         //mt:const uint8(6)
22438                         Tiles        [6]TileDef
22439                         OverlayTiles [6]TileDef
22440                         //mt:const uint8(6)
22441                         SpecialTiles [6]TileDef
22442
22443                         Color   color.NRGBA
22444                         Palette Texture
22445
22446                         Waving       WaveType
22447                         ConnectSides uint8
22448                         ConnectTo    []Content
22449                         InsideTint   color.NRGBA
22450                         Level        uint8 // Must be < 128.
22451
22452                         Translucent bool // Sunlight is scattered and becomes normal light.
22453                         Transparent bool // Sunlight isn't scattered.
22454                         LightSrc    uint8
22455
22456                         GndContent   bool
22457                         Collides     bool
22458                         Pointable    bool
22459                         Diggable     bool
22460                         Climbable    bool
22461                         Replaceable  bool
22462                         OnRightClick bool
22463
22464                         DmgPerSec int32
22465
22466                         LiquidType   LiquidType
22467                         FlowingAlt   string
22468                         SrcAlt       string
22469                         Viscosity    uint8 // 0-7
22470                         LiqRenewable bool
22471                         FlowRange    uint8
22472                         DrownDmg     uint8
22473                         Floodable    bool
22474
22475                         DrawBox, ColBox, SelBox NodeBox
22476
22477                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22478
22479                         LegacyFaceDir bool
22480                         LegacyMounted bool
22481
22482                         DigPredict string
22483
22484                         MaxLvl uint8
22485
22486                         AlphaUse
22487                 }))(obj)).DigPredict) = string(local267)
22488                 {
22489                         p := &(*(*(struct {
22490                                 Param0 Content
22491
22492                                 Name   string
22493                                 Groups []Group
22494
22495                                 P1Type   Param1Type
22496                                 P2Type   Param2Type
22497                                 DrawType DrawType
22498
22499                                 Mesh  string
22500                                 Scale float32
22501                                 //mt:const uint8(6)
22502                                 Tiles        [6]TileDef
22503                                 OverlayTiles [6]TileDef
22504                                 //mt:const uint8(6)
22505                                 SpecialTiles [6]TileDef
22506
22507                                 Color   color.NRGBA
22508                                 Palette Texture
22509
22510                                 Waving       WaveType
22511                                 ConnectSides uint8
22512                                 ConnectTo    []Content
22513                                 InsideTint   color.NRGBA
22514                                 Level        uint8 // Must be < 128.
22515
22516                                 Translucent bool // Sunlight is scattered and becomes normal light.
22517                                 Transparent bool // Sunlight isn't scattered.
22518                                 LightSrc    uint8
22519
22520                                 GndContent   bool
22521                                 Collides     bool
22522                                 Pointable    bool
22523                                 Diggable     bool
22524                                 Climbable    bool
22525                                 Replaceable  bool
22526                                 OnRightClick bool
22527
22528                                 DmgPerSec int32
22529
22530                                 LiquidType   LiquidType
22531                                 FlowingAlt   string
22532                                 SrcAlt       string
22533                                 Viscosity    uint8 // 0-7
22534                                 LiqRenewable bool
22535                                 FlowRange    uint8
22536                                 DrownDmg     uint8
22537                                 Floodable    bool
22538
22539                                 DrawBox, ColBox, SelBox NodeBox
22540
22541                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22542
22543                                 LegacyFaceDir bool
22544                                 LegacyMounted bool
22545
22546                                 DigPredict string
22547
22548                                 MaxLvl uint8
22549
22550                                 AlphaUse
22551                         }))(obj)).MaxLvl
22552                         *p = read8(r)
22553                 }
22554                 if err := pcall(func() {
22555                         ((*(*(struct {
22556                                 Param0 Content
22557
22558                                 Name   string
22559                                 Groups []Group
22560
22561                                 P1Type   Param1Type
22562                                 P2Type   Param2Type
22563                                 DrawType DrawType
22564
22565                                 Mesh  string
22566                                 Scale float32
22567                                 //mt:const uint8(6)
22568                                 Tiles        [6]TileDef
22569                                 OverlayTiles [6]TileDef
22570                                 //mt:const uint8(6)
22571                                 SpecialTiles [6]TileDef
22572
22573                                 Color   color.NRGBA
22574                                 Palette Texture
22575
22576                                 Waving       WaveType
22577                                 ConnectSides uint8
22578                                 ConnectTo    []Content
22579                                 InsideTint   color.NRGBA
22580                                 Level        uint8 // Must be < 128.
22581
22582                                 Translucent bool // Sunlight is scattered and becomes normal light.
22583                                 Transparent bool // Sunlight isn't scattered.
22584                                 LightSrc    uint8
22585
22586                                 GndContent   bool
22587                                 Collides     bool
22588                                 Pointable    bool
22589                                 Diggable     bool
22590                                 Climbable    bool
22591                                 Replaceable  bool
22592                                 OnRightClick bool
22593
22594                                 DmgPerSec int32
22595
22596                                 LiquidType   LiquidType
22597                                 FlowingAlt   string
22598                                 SrcAlt       string
22599                                 Viscosity    uint8 // 0-7
22600                                 LiqRenewable bool
22601                                 FlowRange    uint8
22602                                 DrownDmg     uint8
22603                                 Floodable    bool
22604
22605                                 DrawBox, ColBox, SelBox NodeBox
22606
22607                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22608
22609                                 LegacyFaceDir bool
22610                                 LegacyMounted bool
22611
22612                                 DigPredict string
22613
22614                                 MaxLvl uint8
22615
22616                                 AlphaUse
22617                         }))(obj)).AlphaUse).deserialize(r)
22618                 }); err != nil {
22619                         if err == io.EOF {
22620                                 chk(io.EOF)
22621                         }
22622                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
22623                 }
22624                 if r.N > 0 {
22625                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
22626                 }
22627         }
22628 }
22629
22630 func (obj *PointedNode) serialize(w io.Writer) {
22631         for local269 := range (*(*(struct {
22632                 Under, Above [3]int16
22633         }))(obj)).Under {
22634                 {
22635                         x := ((*(*(struct {
22636                                 Under, Above [3]int16
22637                         }))(obj)).Under)[local269]
22638                         write16(w, uint16(x))
22639                 }
22640         }
22641         for local270 := range (*(*(struct {
22642                 Under, Above [3]int16
22643         }))(obj)).Above {
22644                 {
22645                         x := ((*(*(struct {
22646                                 Under, Above [3]int16
22647                         }))(obj)).Above)[local270]
22648                         write16(w, uint16(x))
22649                 }
22650         }
22651 }
22652
22653 func (obj *PointedNode) deserialize(r io.Reader) {
22654         for local271 := range (*(*(struct {
22655                 Under, Above [3]int16
22656         }))(obj)).Under {
22657                 {
22658                         p := &((*(*(struct {
22659                                 Under, Above [3]int16
22660                         }))(obj)).Under)[local271]
22661                         *p = int16(read16(r))
22662                 }
22663         }
22664         for local272 := range (*(*(struct {
22665                 Under, Above [3]int16
22666         }))(obj)).Above {
22667                 {
22668                         p := &((*(*(struct {
22669                                 Under, Above [3]int16
22670                         }))(obj)).Above)[local272]
22671                         *p = int16(read16(r))
22672                 }
22673         }
22674 }
22675
22676 func (obj *PointedAO) serialize(w io.Writer) {
22677         if err := pcall(func() {
22678                 ((*(*(struct {
22679                         ID AOID
22680                 }))(obj)).ID).serialize(w)
22681         }); err != nil {
22682                 if err == io.EOF {
22683                         chk(io.EOF)
22684                 }
22685                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
22686         }
22687 }
22688
22689 func (obj *PointedAO) deserialize(r io.Reader) {
22690         if err := pcall(func() {
22691                 ((*(*(struct {
22692                         ID AOID
22693                 }))(obj)).ID).deserialize(r)
22694         }); err != nil {
22695                 if err == io.EOF {
22696                         chk(io.EOF)
22697                 }
22698                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
22699         }
22700 }
22701
22702 func (obj *CompressionModes) serialize(w io.Writer) {
22703         {
22704                 x := *(*(uint16))(obj)
22705                 write16(w, uint16(x))
22706         }
22707 }
22708
22709 func (obj *CompressionModes) deserialize(r io.Reader) {
22710         {
22711                 p := &*(*(uint16))(obj)
22712                 *p = read16(r)
22713         }
22714 }
22715
22716 func (obj *PlayerPos) serialize(w io.Writer) {
22717         for local273 := range (*(*(struct {
22718                 Pos100, Vel100   [3]int32
22719                 Pitch100, Yaw100 int32
22720                 Keys             Keys
22721                 FOV80            uint8
22722                 WantedRange      uint8 // in MapBlks.
22723         }))(obj)).Pos100 {
22724                 {
22725                         x := ((*(*(struct {
22726                                 Pos100, Vel100   [3]int32
22727                                 Pitch100, Yaw100 int32
22728                                 Keys             Keys
22729                                 FOV80            uint8
22730                                 WantedRange      uint8 // in MapBlks.
22731                         }))(obj)).Pos100)[local273]
22732                         write32(w, uint32(x))
22733                 }
22734         }
22735         for local274 := range (*(*(struct {
22736                 Pos100, Vel100   [3]int32
22737                 Pitch100, Yaw100 int32
22738                 Keys             Keys
22739                 FOV80            uint8
22740                 WantedRange      uint8 // in MapBlks.
22741         }))(obj)).Vel100 {
22742                 {
22743                         x := ((*(*(struct {
22744                                 Pos100, Vel100   [3]int32
22745                                 Pitch100, Yaw100 int32
22746                                 Keys             Keys
22747                                 FOV80            uint8
22748                                 WantedRange      uint8 // in MapBlks.
22749                         }))(obj)).Vel100)[local274]
22750                         write32(w, uint32(x))
22751                 }
22752         }
22753         {
22754                 x := (*(*(struct {
22755                         Pos100, Vel100   [3]int32
22756                         Pitch100, Yaw100 int32
22757                         Keys             Keys
22758                         FOV80            uint8
22759                         WantedRange      uint8 // in MapBlks.
22760                 }))(obj)).Pitch100
22761                 write32(w, uint32(x))
22762         }
22763         {
22764                 x := (*(*(struct {
22765                         Pos100, Vel100   [3]int32
22766                         Pitch100, Yaw100 int32
22767                         Keys             Keys
22768                         FOV80            uint8
22769                         WantedRange      uint8 // in MapBlks.
22770                 }))(obj)).Yaw100
22771                 write32(w, uint32(x))
22772         }
22773         if err := pcall(func() {
22774                 ((*(*(struct {
22775                         Pos100, Vel100   [3]int32
22776                         Pitch100, Yaw100 int32
22777                         Keys             Keys
22778                         FOV80            uint8
22779                         WantedRange      uint8 // in MapBlks.
22780                 }))(obj)).Keys).serialize(w)
22781         }); err != nil {
22782                 if err == io.EOF {
22783                         chk(io.EOF)
22784                 }
22785                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
22786         }
22787         {
22788                 x := (*(*(struct {
22789                         Pos100, Vel100   [3]int32
22790                         Pitch100, Yaw100 int32
22791                         Keys             Keys
22792                         FOV80            uint8
22793                         WantedRange      uint8 // in MapBlks.
22794                 }))(obj)).FOV80
22795                 write8(w, uint8(x))
22796         }
22797         {
22798                 x := (*(*(struct {
22799                         Pos100, Vel100   [3]int32
22800                         Pitch100, Yaw100 int32
22801                         Keys             Keys
22802                         FOV80            uint8
22803                         WantedRange      uint8 // in MapBlks.
22804                 }))(obj)).WantedRange
22805                 write8(w, uint8(x))
22806         }
22807 }
22808
22809 func (obj *PlayerPos) deserialize(r io.Reader) {
22810         for local275 := range (*(*(struct {
22811                 Pos100, Vel100   [3]int32
22812                 Pitch100, Yaw100 int32
22813                 Keys             Keys
22814                 FOV80            uint8
22815                 WantedRange      uint8 // in MapBlks.
22816         }))(obj)).Pos100 {
22817                 {
22818                         p := &((*(*(struct {
22819                                 Pos100, Vel100   [3]int32
22820                                 Pitch100, Yaw100 int32
22821                                 Keys             Keys
22822                                 FOV80            uint8
22823                                 WantedRange      uint8 // in MapBlks.
22824                         }))(obj)).Pos100)[local275]
22825                         *p = int32(read32(r))
22826                 }
22827         }
22828         for local276 := range (*(*(struct {
22829                 Pos100, Vel100   [3]int32
22830                 Pitch100, Yaw100 int32
22831                 Keys             Keys
22832                 FOV80            uint8
22833                 WantedRange      uint8 // in MapBlks.
22834         }))(obj)).Vel100 {
22835                 {
22836                         p := &((*(*(struct {
22837                                 Pos100, Vel100   [3]int32
22838                                 Pitch100, Yaw100 int32
22839                                 Keys             Keys
22840                                 FOV80            uint8
22841                                 WantedRange      uint8 // in MapBlks.
22842                         }))(obj)).Vel100)[local276]
22843                         *p = int32(read32(r))
22844                 }
22845         }
22846         {
22847                 p := &(*(*(struct {
22848                         Pos100, Vel100   [3]int32
22849                         Pitch100, Yaw100 int32
22850                         Keys             Keys
22851                         FOV80            uint8
22852                         WantedRange      uint8 // in MapBlks.
22853                 }))(obj)).Pitch100
22854                 *p = int32(read32(r))
22855         }
22856         {
22857                 p := &(*(*(struct {
22858                         Pos100, Vel100   [3]int32
22859                         Pitch100, Yaw100 int32
22860                         Keys             Keys
22861                         FOV80            uint8
22862                         WantedRange      uint8 // in MapBlks.
22863                 }))(obj)).Yaw100
22864                 *p = int32(read32(r))
22865         }
22866         if err := pcall(func() {
22867                 ((*(*(struct {
22868                         Pos100, Vel100   [3]int32
22869                         Pitch100, Yaw100 int32
22870                         Keys             Keys
22871                         FOV80            uint8
22872                         WantedRange      uint8 // in MapBlks.
22873                 }))(obj)).Keys).deserialize(r)
22874         }); err != nil {
22875                 if err == io.EOF {
22876                         chk(io.EOF)
22877                 }
22878                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
22879         }
22880         {
22881                 p := &(*(*(struct {
22882                         Pos100, Vel100   [3]int32
22883                         Pitch100, Yaw100 int32
22884                         Keys             Keys
22885                         FOV80            uint8
22886                         WantedRange      uint8 // in MapBlks.
22887                 }))(obj)).FOV80
22888                 *p = read8(r)
22889         }
22890         {
22891                 p := &(*(*(struct {
22892                         Pos100, Vel100   [3]int32
22893                         Pitch100, Yaw100 int32
22894                         Keys             Keys
22895                         FOV80            uint8
22896                         WantedRange      uint8 // in MapBlks.
22897                 }))(obj)).WantedRange
22898                 *p = read8(r)
22899         }
22900 }
22901
22902 func (obj *Interaction) serialize(w io.Writer) {
22903         {
22904                 x := *(*(uint8))(obj)
22905                 write8(w, uint8(x))
22906         }
22907 }
22908
22909 func (obj *Interaction) deserialize(r io.Reader) {
22910         {
22911                 p := &*(*(uint8))(obj)
22912                 *p = read8(r)
22913         }
22914 }
22915
22916 func (obj *SoundID) serialize(w io.Writer) {
22917         {
22918                 x := *(*(int32))(obj)
22919                 write32(w, uint32(x))
22920         }
22921 }
22922
22923 func (obj *SoundID) deserialize(r io.Reader) {
22924         {
22925                 p := &*(*(int32))(obj)
22926                 *p = int32(read32(r))
22927         }
22928 }
22929
22930 func (obj *Field) serialize(w io.Writer) {
22931         if len(([]byte((*(*(struct {
22932                 Name string
22933
22934                 //mt:len32
22935                 Value string
22936         }))(obj)).Name))) > math.MaxUint16 {
22937                 chk(ErrTooLong)
22938         }
22939         {
22940                 x := uint16(len(([]byte((*(*(struct {
22941                         Name string
22942
22943                         //mt:len32
22944                         Value string
22945                 }))(obj)).Name))))
22946                 write16(w, uint16(x))
22947         }
22948         {
22949                 _, err := w.Write(([]byte((*(*(struct {
22950                         Name string
22951
22952                         //mt:len32
22953                         Value string
22954                 }))(obj)).Name))[:])
22955                 chk(err)
22956         }
22957         if len(([]byte((*(*(struct {
22958                 Name string
22959
22960                 //mt:len32
22961                 Value string
22962         }))(obj)).Value))) > math.MaxUint32 {
22963                 chk(ErrTooLong)
22964         }
22965         {
22966                 x := uint32(len(([]byte((*(*(struct {
22967                         Name string
22968
22969                         //mt:len32
22970                         Value string
22971                 }))(obj)).Value))))
22972                 write32(w, uint32(x))
22973         }
22974         {
22975                 _, err := w.Write(([]byte((*(*(struct {
22976                         Name string
22977
22978                         //mt:len32
22979                         Value string
22980                 }))(obj)).Value))[:])
22981                 chk(err)
22982         }
22983 }
22984
22985 func (obj *Field) deserialize(r io.Reader) {
22986         var local277 []uint8
22987         var local278 uint16
22988         {
22989                 p := &local278
22990                 *p = read16(r)
22991         }
22992         (local277) = make([]uint8, local278)
22993         {
22994                 _, err := io.ReadFull(r, (local277)[:])
22995                 chk(err)
22996         }
22997         ((*(*(struct {
22998                 Name string
22999
23000                 //mt:len32
23001                 Value string
23002         }))(obj)).Name) = string(local277)
23003         var local279 []uint8
23004         var local280 uint32
23005         {
23006                 p := &local280
23007                 *p = read32(r)
23008         }
23009         (local279) = make([]uint8, local280)
23010         {
23011                 _, err := io.ReadFull(r, (local279)[:])
23012                 chk(err)
23013         }
23014         ((*(*(struct {
23015                 Name string
23016
23017                 //mt:len32
23018                 Value string
23019         }))(obj)).Value) = string(local279)
23020 }
23021
23022 func (obj *AuthMethods) serialize(w io.Writer) {
23023         {
23024                 x := *(*(uint32))(obj)
23025                 write32(w, uint32(x))
23026         }
23027 }
23028
23029 func (obj *AuthMethods) deserialize(r io.Reader) {
23030         {
23031                 p := &*(*(uint32))(obj)
23032                 *p = read32(r)
23033         }
23034 }
23035
23036 func (obj *Pos) serialize(w io.Writer) {
23037         if err := pcall(func() {
23038                 (*(*(Vec))(obj)).serialize(w)
23039         }); err != nil {
23040                 if err == io.EOF {
23041                         chk(io.EOF)
23042                 }
23043                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23044         }
23045 }
23046
23047 func (obj *Pos) deserialize(r io.Reader) {
23048         if err := pcall(func() {
23049                 (*(*(Vec))(obj)).deserialize(r)
23050         }); err != nil {
23051                 if err == io.EOF {
23052                         chk(io.EOF)
23053                 }
23054                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23055         }
23056 }
23057
23058 func (obj *KickReason) serialize(w io.Writer) {
23059         {
23060                 x := *(*(uint8))(obj)
23061                 write8(w, uint8(x))
23062         }
23063 }
23064
23065 func (obj *KickReason) deserialize(r io.Reader) {
23066         {
23067                 p := &*(*(uint8))(obj)
23068                 *p = read8(r)
23069         }
23070 }
23071
23072 func (obj *MapBlk) serialize(w io.Writer) {
23073         if err := pcall(func() {
23074                 ((*(*(struct {
23075                         Flags   MapBlkFlags
23076                         LitFrom LitFromBlks
23077
23078                         //mt:zstd
23079                         Param0 [4096]Content
23080                         Param1 [4096]uint8
23081                         Param2 [4096]uint8
23082
23083                         NodeMetas map[uint16]*NodeMeta
23084                 }))(obj)).Flags).serialize(w)
23085         }); err != nil {
23086                 if err == io.EOF {
23087                         chk(io.EOF)
23088                 }
23089                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
23090         }
23091         if err := pcall(func() {
23092                 ((*(*(struct {
23093                         Flags   MapBlkFlags
23094                         LitFrom LitFromBlks
23095
23096                         //mt:zstd
23097                         Param0 [4096]Content
23098                         Param1 [4096]uint8
23099                         Param2 [4096]uint8
23100
23101                         NodeMetas map[uint16]*NodeMeta
23102                 }))(obj)).LitFrom).serialize(w)
23103         }); err != nil {
23104                 if err == io.EOF {
23105                         chk(io.EOF)
23106                 }
23107                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
23108         }
23109         {
23110                 local281 := uint8(2) // Size of param0 in bytes.
23111                 {
23112                         x := local281
23113                         write8(w, uint8(x))
23114                 }
23115         }
23116         {
23117                 local282 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23118                 {
23119                         x := local282
23120                         write8(w, uint8(x))
23121                 }
23122         }
23123         {
23124                 w, err := zstd.NewWriter(w)
23125                 chk(err)
23126                 for local283 := range (*(*(struct {
23127                         Flags   MapBlkFlags
23128                         LitFrom LitFromBlks
23129
23130                         //mt:zstd
23131                         Param0 [4096]Content
23132                         Param1 [4096]uint8
23133                         Param2 [4096]uint8
23134
23135                         NodeMetas map[uint16]*NodeMeta
23136                 }))(obj)).Param0 {
23137                         if err := pcall(func() {
23138                                 (((*(*(struct {
23139                                         Flags   MapBlkFlags
23140                                         LitFrom LitFromBlks
23141
23142                                         //mt:zstd
23143                                         Param0 [4096]Content
23144                                         Param1 [4096]uint8
23145                                         Param2 [4096]uint8
23146
23147                                         NodeMetas map[uint16]*NodeMeta
23148                                 }))(obj)).Param0)[local283]).serialize(w)
23149                         }); err != nil {
23150                                 if err == io.EOF {
23151                                         chk(io.EOF)
23152                                 }
23153                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
23154                         }
23155                 }
23156                 {
23157                         _, err := w.Write(((*(*(struct {
23158                                 Flags   MapBlkFlags
23159                                 LitFrom LitFromBlks
23160
23161                                 //mt:zstd
23162                                 Param0 [4096]Content
23163                                 Param1 [4096]uint8
23164                                 Param2 [4096]uint8
23165
23166                                 NodeMetas map[uint16]*NodeMeta
23167                         }))(obj)).Param1)[:])
23168                         chk(err)
23169                 }
23170                 {
23171                         _, err := w.Write(((*(*(struct {
23172                                 Flags   MapBlkFlags
23173                                 LitFrom LitFromBlks
23174
23175                                 //mt:zstd
23176                                 Param0 [4096]Content
23177                                 Param1 [4096]uint8
23178                                 Param2 [4096]uint8
23179
23180                                 NodeMetas map[uint16]*NodeMeta
23181                         }))(obj)).Param2)[:])
23182                         chk(err)
23183                 }
23184                 chk(w.Close())
23185         }
23186         {
23187                 x := (*(*(struct {
23188                         Flags   MapBlkFlags
23189                         LitFrom LitFromBlks
23190
23191                         //mt:zstd
23192                         Param0 [4096]Content
23193                         Param1 [4096]uint8
23194                         Param2 [4096]uint8
23195
23196                         NodeMetas map[uint16]*NodeMeta
23197                 }))(obj)).NodeMetas
23198                 {
23199                         w := zlib.NewWriter(w)
23200                         if x == nil {
23201                                 write8(w, 0)
23202                         } else {
23203                                 write8(w, 2)
23204                                 // len(map[uint16]...) always < math.MaxUint16
23205                                 write16(w, uint16(len(x)))
23206                                 keys := make([]uint16, 0, len(x))
23207                                 for key := range x {
23208                                         keys = append(keys, key)
23209                                 }
23210                                 sort.Slice(keys, func(i, j int) bool {
23211                                         i2pos := func(i int) [3]int16 {
23212                                                 return Blkpos2Pos([3]int16{}, keys[i])
23213                                         }
23214                                         p, q := i2pos(i), i2pos(j)
23215                                         for i := range p {
23216                                                 switch {
23217                                                 case p[i] < q[i]:
23218                                                         return true
23219                                                 case p[i] > q[i]:
23220                                                         return false
23221                                                 }
23222                                         }
23223                                         return false
23224                                 })
23225                                 for _, key := range keys {
23226                                         write16(w, key)
23227                                         chk(serialize(w, x[key]))
23228                                 }
23229                         }
23230                         chk(w.Close())
23231                 }
23232         }
23233         {
23234                 local284 := uint8(2) // version
23235                 {
23236                         x := local284
23237                         write8(w, uint8(x))
23238                 }
23239         }
23240 }
23241
23242 func (obj *MapBlk) deserialize(r io.Reader) {
23243         if err := pcall(func() {
23244                 ((*(*(struct {
23245                         Flags   MapBlkFlags
23246                         LitFrom LitFromBlks
23247
23248                         //mt:zstd
23249                         Param0 [4096]Content
23250                         Param1 [4096]uint8
23251                         Param2 [4096]uint8
23252
23253                         NodeMetas map[uint16]*NodeMeta
23254                 }))(obj)).Flags).deserialize(r)
23255         }); err != nil {
23256                 if err == io.EOF {
23257                         chk(io.EOF)
23258                 }
23259                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
23260         }
23261         if err := pcall(func() {
23262                 ((*(*(struct {
23263                         Flags   MapBlkFlags
23264                         LitFrom LitFromBlks
23265
23266                         //mt:zstd
23267                         Param0 [4096]Content
23268                         Param1 [4096]uint8
23269                         Param2 [4096]uint8
23270
23271                         NodeMetas map[uint16]*NodeMeta
23272                 }))(obj)).LitFrom).deserialize(r)
23273         }); err != nil {
23274                 if err == io.EOF {
23275                         chk(io.EOF)
23276                 }
23277                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
23278         }
23279         {
23280                 var local285 uint8
23281                 local286 := uint8(2) // Size of param0 in bytes.
23282                 {
23283                         p := &local285
23284                         *p = read8(r)
23285                 }
23286                 if local285 != local286 {
23287                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local285))
23288                 }
23289         }
23290         {
23291                 var local287 uint8
23292                 local288 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23293                 {
23294                         p := &local287
23295                         *p = read8(r)
23296                 }
23297                 if local287 != local288 {
23298                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local287))
23299                 }
23300         }
23301         {
23302                 r, err := zstd.NewReader(byteReader{r})
23303                 chk(err)
23304                 for local289 := range (*(*(struct {
23305                         Flags   MapBlkFlags
23306                         LitFrom LitFromBlks
23307
23308                         //mt:zstd
23309                         Param0 [4096]Content
23310                         Param1 [4096]uint8
23311                         Param2 [4096]uint8
23312
23313                         NodeMetas map[uint16]*NodeMeta
23314                 }))(obj)).Param0 {
23315                         if err := pcall(func() {
23316                                 (((*(*(struct {
23317                                         Flags   MapBlkFlags
23318                                         LitFrom LitFromBlks
23319
23320                                         //mt:zstd
23321                                         Param0 [4096]Content
23322                                         Param1 [4096]uint8
23323                                         Param2 [4096]uint8
23324
23325                                         NodeMetas map[uint16]*NodeMeta
23326                                 }))(obj)).Param0)[local289]).deserialize(r)
23327                         }); err != nil {
23328                                 if err == io.EOF {
23329                                         chk(io.EOF)
23330                                 }
23331                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
23332                         }
23333                 }
23334                 {
23335                         _, err := io.ReadFull(r, ((*(*(struct {
23336                                 Flags   MapBlkFlags
23337                                 LitFrom LitFromBlks
23338
23339                                 //mt:zstd
23340                                 Param0 [4096]Content
23341                                 Param1 [4096]uint8
23342                                 Param2 [4096]uint8
23343
23344                                 NodeMetas map[uint16]*NodeMeta
23345                         }))(obj)).Param1)[:])
23346                         chk(err)
23347                 }
23348                 {
23349                         _, err := io.ReadFull(r, ((*(*(struct {
23350                                 Flags   MapBlkFlags
23351                                 LitFrom LitFromBlks
23352
23353                                 //mt:zstd
23354                                 Param0 [4096]Content
23355                                 Param1 [4096]uint8
23356                                 Param2 [4096]uint8
23357
23358                                 NodeMetas map[uint16]*NodeMeta
23359                         }))(obj)).Param2)[:])
23360                         chk(err)
23361                 }
23362                 r.Close()
23363         }
23364         {
23365                 p := &(*(*(struct {
23366                         Flags   MapBlkFlags
23367                         LitFrom LitFromBlks
23368
23369                         //mt:zstd
23370                         Param0 [4096]Content
23371                         Param1 [4096]uint8
23372                         Param2 [4096]uint8
23373
23374                         NodeMetas map[uint16]*NodeMeta
23375                 }))(obj)).NodeMetas
23376                 {
23377                         r, err := zlib.NewReader(byteReader{r})
23378                         chk(err)
23379                         switch ver := read8(r); ver {
23380                         case 0:
23381                                 *p = nil
23382                         case 2:
23383                                 n := read16(r)
23384                                 *p = make(map[uint16]*NodeMeta, n)
23385                                 for ; n > 0; n-- {
23386                                         pos := read16(r)
23387                                         nm := new(NodeMeta)
23388                                         chk(deserialize(r, nm))
23389                                         (*p)[pos] = nm
23390                                 }
23391                         default:
23392                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
23393                         }
23394                         chk(r.Close())
23395                 }
23396         }
23397         {
23398                 var local290 uint8
23399                 local291 := uint8(2) // version
23400                 {
23401                         p := &local290
23402                         *p = read8(r)
23403                 }
23404                 if local290 != local291 {
23405                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local290))
23406                 }
23407         }
23408 }
23409
23410 func (obj *Node) serialize(w io.Writer) {
23411         if err := pcall(func() {
23412                 ((*(*(struct {
23413                         Param0         Content
23414                         Param1, Param2 uint8
23415                 }))(obj)).Param0).serialize(w)
23416         }); err != nil {
23417                 if err == io.EOF {
23418                         chk(io.EOF)
23419                 }
23420                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
23421         }
23422         {
23423                 x := (*(*(struct {
23424                         Param0         Content
23425                         Param1, Param2 uint8
23426                 }))(obj)).Param1
23427                 write8(w, uint8(x))
23428         }
23429         {
23430                 x := (*(*(struct {
23431                         Param0         Content
23432                         Param1, Param2 uint8
23433                 }))(obj)).Param2
23434                 write8(w, uint8(x))
23435         }
23436 }
23437
23438 func (obj *Node) deserialize(r io.Reader) {
23439         if err := pcall(func() {
23440                 ((*(*(struct {
23441                         Param0         Content
23442                         Param1, Param2 uint8
23443                 }))(obj)).Param0).deserialize(r)
23444         }); err != nil {
23445                 if err == io.EOF {
23446                         chk(io.EOF)
23447                 }
23448                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
23449         }
23450         {
23451                 p := &(*(*(struct {
23452                         Param0         Content
23453                         Param1, Param2 uint8
23454                 }))(obj)).Param1
23455                 *p = read8(r)
23456         }
23457         {
23458                 p := &(*(*(struct {
23459                         Param0         Content
23460                         Param1, Param2 uint8
23461                 }))(obj)).Param2
23462                 *p = read8(r)
23463         }
23464 }
23465
23466 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
23467         {
23468                 x := *(*(uint64))(obj)
23469                 write64(w, uint64(x))
23470         }
23471 }
23472
23473 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
23474         {
23475                 p := &*(*(uint64))(obj)
23476                 *p = read64(r)
23477         }
23478 }
23479
23480 func (obj *Vec) serialize(w io.Writer) {
23481         for local292 := range *(*([3]float32))(obj) {
23482                 {
23483                         x := (*(*([3]float32))(obj))[local292]
23484                         write32(w, math.Float32bits(x))
23485                 }
23486         }
23487 }
23488
23489 func (obj *Vec) deserialize(r io.Reader) {
23490         for local293 := range *(*([3]float32))(obj) {
23491                 {
23492                         p := &(*(*([3]float32))(obj))[local293]
23493                         *p = math.Float32frombits(read32(r))
23494                 }
23495         }
23496 }
23497
23498 func (obj *ChatMsgType) serialize(w io.Writer) {
23499         {
23500                 x := *(*(uint8))(obj)
23501                 write8(w, uint8(x))
23502         }
23503 }
23504
23505 func (obj *ChatMsgType) deserialize(r io.Reader) {
23506         {
23507                 p := &*(*(uint8))(obj)
23508                 *p = read8(r)
23509         }
23510 }
23511
23512 func (obj *AOID) serialize(w io.Writer) {
23513         {
23514                 x := *(*(uint16))(obj)
23515                 write16(w, uint16(x))
23516         }
23517 }
23518
23519 func (obj *AOID) deserialize(r io.Reader) {
23520         {
23521                 p := &*(*(uint16))(obj)
23522                 *p = read16(r)
23523         }
23524 }
23525
23526 func (obj *AOAdd) serialize(w io.Writer) {
23527         if err := pcall(func() {
23528                 ((*(*(struct {
23529                         ID AOID
23530                         //mt:const genericCAO
23531                         //mt:lenhdr 32
23532                         InitData AOInitData
23533                 }))(obj)).ID).serialize(w)
23534         }); err != nil {
23535                 if err == io.EOF {
23536                         chk(io.EOF)
23537                 }
23538                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23539         }
23540         {
23541                 local294 := genericCAO
23542                 if err := pcall(func() {
23543                         (local294).serialize(w)
23544                 }); err != nil {
23545                         if err == io.EOF {
23546                                 chk(io.EOF)
23547                         }
23548                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
23549                 }
23550         }
23551         {
23552                 ow := w
23553                 w := new(bytes.Buffer)
23554                 if err := pcall(func() {
23555                         ((*(*(struct {
23556                                 ID AOID
23557                                 //mt:const genericCAO
23558                                 //mt:lenhdr 32
23559                                 InitData AOInitData
23560                         }))(obj)).InitData).serialize(w)
23561                 }); err != nil {
23562                         if err == io.EOF {
23563                                 chk(io.EOF)
23564                         }
23565                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
23566                 }
23567                 {
23568                         buf := w
23569                         w := ow
23570                         if len((buf.Bytes())) > math.MaxUint32 {
23571                                 chk(ErrTooLong)
23572                         }
23573                         {
23574                                 x := uint32(len((buf.Bytes())))
23575                                 write32(w, uint32(x))
23576                         }
23577                         {
23578                                 _, err := w.Write((buf.Bytes())[:])
23579                                 chk(err)
23580                         }
23581                 }
23582         }
23583 }
23584
23585 func (obj *AOAdd) deserialize(r io.Reader) {
23586         if err := pcall(func() {
23587                 ((*(*(struct {
23588                         ID AOID
23589                         //mt:const genericCAO
23590                         //mt:lenhdr 32
23591                         InitData AOInitData
23592                 }))(obj)).ID).deserialize(r)
23593         }); err != nil {
23594                 if err == io.EOF {
23595                         chk(io.EOF)
23596                 }
23597                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23598         }
23599         {
23600                 var local295 aoType
23601                 local296 := genericCAO
23602                 if err := pcall(func() {
23603                         (local295).deserialize(r)
23604                 }); err != nil {
23605                         if err == io.EOF {
23606                                 chk(io.EOF)
23607                         }
23608                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
23609                 }
23610                 if local295 != local296 {
23611                         chk(fmt.Errorf("const %v: %v", "genericCAO", local295))
23612                 }
23613         }
23614         {
23615                 var n uint32
23616                 {
23617                         p := &n
23618                         *p = read32(r)
23619                 }
23620                 r := &io.LimitedReader{R: r, N: int64(n)}
23621                 if err := pcall(func() {
23622                         ((*(*(struct {
23623                                 ID AOID
23624                                 //mt:const genericCAO
23625                                 //mt:lenhdr 32
23626                                 InitData AOInitData
23627                         }))(obj)).InitData).deserialize(r)
23628                 }); err != nil {
23629                         if err == io.EOF {
23630                                 chk(io.EOF)
23631                         }
23632                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
23633                 }
23634                 if r.N > 0 {
23635                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23636                 }
23637         }
23638 }
23639
23640 func (obj *IDAOMsg) serialize(w io.Writer) {
23641         if err := pcall(func() {
23642                 ((*(*(struct {
23643                         ID AOID
23644                         //mt:lenhdr 16
23645                         Msg AOMsg
23646                 }))(obj)).ID).serialize(w)
23647         }); err != nil {
23648                 if err == io.EOF {
23649                         chk(io.EOF)
23650                 }
23651                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23652         }
23653         {
23654                 ow := w
23655                 w := new(bytes.Buffer)
23656                 {
23657                         x := (*(*(struct {
23658                                 ID AOID
23659                                 //mt:lenhdr 16
23660                                 Msg AOMsg
23661                         }))(obj)).Msg
23662                         writeAOMsg(w, x)
23663                 }
23664                 {
23665                         buf := w
23666                         w := ow
23667                         if len((buf.Bytes())) > math.MaxUint16 {
23668                                 chk(ErrTooLong)
23669                         }
23670                         {
23671                                 x := uint16(len((buf.Bytes())))
23672                                 write16(w, uint16(x))
23673                         }
23674                         {
23675                                 _, err := w.Write((buf.Bytes())[:])
23676                                 chk(err)
23677                         }
23678                 }
23679         }
23680 }
23681
23682 func (obj *IDAOMsg) deserialize(r io.Reader) {
23683         if err := pcall(func() {
23684                 ((*(*(struct {
23685                         ID AOID
23686                         //mt:lenhdr 16
23687                         Msg AOMsg
23688                 }))(obj)).ID).deserialize(r)
23689         }); err != nil {
23690                 if err == io.EOF {
23691                         chk(io.EOF)
23692                 }
23693                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23694         }
23695         {
23696                 var n uint16
23697                 {
23698                         p := &n
23699                         *p = read16(r)
23700                 }
23701                 r := &io.LimitedReader{R: r, N: int64(n)}
23702                 {
23703                         p := &(*(*(struct {
23704                                 ID AOID
23705                                 //mt:lenhdr 16
23706                                 Msg AOMsg
23707                         }))(obj)).Msg
23708                         {
23709                                 var err error
23710                                 *p, err = readAOMsg(r)
23711                                 chk(err)
23712                         }
23713                 }
23714                 if r.N > 0 {
23715                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23716                 }
23717         }
23718 }
23719
23720 func (obj *ItemDef) serialize(w io.Writer) {
23721         {
23722                 ow := w
23723                 w := new(bytes.Buffer)
23724                 {
23725                         local297 := uint8(6)
23726                         {
23727                                 x := local297
23728                                 write8(w, uint8(x))
23729                         }
23730                 }
23731                 if err := pcall(func() {
23732                         ((*(*(struct {
23733                                 Type ItemType
23734
23735                                 Name, Desc string
23736
23737                                 InvImg, WieldImg Texture
23738                                 WieldScale       [3]float32
23739
23740                                 StackMax uint16
23741
23742                                 Usable          bool
23743                                 CanPointLiquids bool
23744
23745                                 ToolCaps ToolCaps
23746
23747                                 Groups []Group
23748
23749                                 PlacePredict string
23750
23751                                 PlaceSnd, PlaceFailSnd SoundDef
23752
23753                                 PointRange float32
23754
23755                                 // Set index in Palette with "palette_index" item meta field,
23756                                 // this overrides Color.
23757                                 Palette Texture
23758                                 Color   color.NRGBA
23759
23760                                 // Texture overlays.
23761                                 InvOverlay, WieldOverlay Texture
23762
23763                                 ShortDesc string
23764                         }))(obj)).Type).serialize(w)
23765                 }); err != nil {
23766                         if err == io.EOF {
23767                                 chk(io.EOF)
23768                         }
23769                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
23770                 }
23771                 if len(([]byte((*(*(struct {
23772                         Type ItemType
23773
23774                         Name, Desc string
23775
23776                         InvImg, WieldImg Texture
23777                         WieldScale       [3]float32
23778
23779                         StackMax uint16
23780
23781                         Usable          bool
23782                         CanPointLiquids bool
23783
23784                         ToolCaps ToolCaps
23785
23786                         Groups []Group
23787
23788                         PlacePredict string
23789
23790                         PlaceSnd, PlaceFailSnd SoundDef
23791
23792                         PointRange float32
23793
23794                         // Set index in Palette with "palette_index" item meta field,
23795                         // this overrides Color.
23796                         Palette Texture
23797                         Color   color.NRGBA
23798
23799                         // Texture overlays.
23800                         InvOverlay, WieldOverlay Texture
23801
23802                         ShortDesc string
23803                 }))(obj)).Name))) > math.MaxUint16 {
23804                         chk(ErrTooLong)
23805                 }
23806                 {
23807                         x := uint16(len(([]byte((*(*(struct {
23808                                 Type ItemType
23809
23810                                 Name, Desc string
23811
23812                                 InvImg, WieldImg Texture
23813                                 WieldScale       [3]float32
23814
23815                                 StackMax uint16
23816
23817                                 Usable          bool
23818                                 CanPointLiquids bool
23819
23820                                 ToolCaps ToolCaps
23821
23822                                 Groups []Group
23823
23824                                 PlacePredict string
23825
23826                                 PlaceSnd, PlaceFailSnd SoundDef
23827
23828                                 PointRange float32
23829
23830                                 // Set index in Palette with "palette_index" item meta field,
23831                                 // this overrides Color.
23832                                 Palette Texture
23833                                 Color   color.NRGBA
23834
23835                                 // Texture overlays.
23836                                 InvOverlay, WieldOverlay Texture
23837
23838                                 ShortDesc string
23839                         }))(obj)).Name))))
23840                         write16(w, uint16(x))
23841                 }
23842                 {
23843                         _, err := w.Write(([]byte((*(*(struct {
23844                                 Type ItemType
23845
23846                                 Name, Desc string
23847
23848                                 InvImg, WieldImg Texture
23849                                 WieldScale       [3]float32
23850
23851                                 StackMax uint16
23852
23853                                 Usable          bool
23854                                 CanPointLiquids bool
23855
23856                                 ToolCaps ToolCaps
23857
23858                                 Groups []Group
23859
23860                                 PlacePredict string
23861
23862                                 PlaceSnd, PlaceFailSnd SoundDef
23863
23864                                 PointRange float32
23865
23866                                 // Set index in Palette with "palette_index" item meta field,
23867                                 // this overrides Color.
23868                                 Palette Texture
23869                                 Color   color.NRGBA
23870
23871                                 // Texture overlays.
23872                                 InvOverlay, WieldOverlay Texture
23873
23874                                 ShortDesc string
23875                         }))(obj)).Name))[:])
23876                         chk(err)
23877                 }
23878                 if len(([]byte((*(*(struct {
23879                         Type ItemType
23880
23881                         Name, Desc string
23882
23883                         InvImg, WieldImg Texture
23884                         WieldScale       [3]float32
23885
23886                         StackMax uint16
23887
23888                         Usable          bool
23889                         CanPointLiquids bool
23890
23891                         ToolCaps ToolCaps
23892
23893                         Groups []Group
23894
23895                         PlacePredict string
23896
23897                         PlaceSnd, PlaceFailSnd SoundDef
23898
23899                         PointRange float32
23900
23901                         // Set index in Palette with "palette_index" item meta field,
23902                         // this overrides Color.
23903                         Palette Texture
23904                         Color   color.NRGBA
23905
23906                         // Texture overlays.
23907                         InvOverlay, WieldOverlay Texture
23908
23909                         ShortDesc string
23910                 }))(obj)).Desc))) > math.MaxUint16 {
23911                         chk(ErrTooLong)
23912                 }
23913                 {
23914                         x := uint16(len(([]byte((*(*(struct {
23915                                 Type ItemType
23916
23917                                 Name, Desc string
23918
23919                                 InvImg, WieldImg Texture
23920                                 WieldScale       [3]float32
23921
23922                                 StackMax uint16
23923
23924                                 Usable          bool
23925                                 CanPointLiquids bool
23926
23927                                 ToolCaps ToolCaps
23928
23929                                 Groups []Group
23930
23931                                 PlacePredict string
23932
23933                                 PlaceSnd, PlaceFailSnd SoundDef
23934
23935                                 PointRange float32
23936
23937                                 // Set index in Palette with "palette_index" item meta field,
23938                                 // this overrides Color.
23939                                 Palette Texture
23940                                 Color   color.NRGBA
23941
23942                                 // Texture overlays.
23943                                 InvOverlay, WieldOverlay Texture
23944
23945                                 ShortDesc string
23946                         }))(obj)).Desc))))
23947                         write16(w, uint16(x))
23948                 }
23949                 {
23950                         _, err := w.Write(([]byte((*(*(struct {
23951                                 Type ItemType
23952
23953                                 Name, Desc string
23954
23955                                 InvImg, WieldImg Texture
23956                                 WieldScale       [3]float32
23957
23958                                 StackMax uint16
23959
23960                                 Usable          bool
23961                                 CanPointLiquids bool
23962
23963                                 ToolCaps ToolCaps
23964
23965                                 Groups []Group
23966
23967                                 PlacePredict string
23968
23969                                 PlaceSnd, PlaceFailSnd SoundDef
23970
23971                                 PointRange float32
23972
23973                                 // Set index in Palette with "palette_index" item meta field,
23974                                 // this overrides Color.
23975                                 Palette Texture
23976                                 Color   color.NRGBA
23977
23978                                 // Texture overlays.
23979                                 InvOverlay, WieldOverlay Texture
23980
23981                                 ShortDesc string
23982                         }))(obj)).Desc))[:])
23983                         chk(err)
23984                 }
23985                 if err := pcall(func() {
23986                         ((*(*(struct {
23987                                 Type ItemType
23988
23989                                 Name, Desc string
23990
23991                                 InvImg, WieldImg Texture
23992                                 WieldScale       [3]float32
23993
23994                                 StackMax uint16
23995
23996                                 Usable          bool
23997                                 CanPointLiquids bool
23998
23999                                 ToolCaps ToolCaps
24000
24001                                 Groups []Group
24002
24003                                 PlacePredict string
24004
24005                                 PlaceSnd, PlaceFailSnd SoundDef
24006
24007                                 PointRange float32
24008
24009                                 // Set index in Palette with "palette_index" item meta field,
24010                                 // this overrides Color.
24011                                 Palette Texture
24012                                 Color   color.NRGBA
24013
24014                                 // Texture overlays.
24015                                 InvOverlay, WieldOverlay Texture
24016
24017                                 ShortDesc string
24018                         }))(obj)).InvImg).serialize(w)
24019                 }); err != nil {
24020                         if err == io.EOF {
24021                                 chk(io.EOF)
24022                         }
24023                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24024                 }
24025                 if err := pcall(func() {
24026                         ((*(*(struct {
24027                                 Type ItemType
24028
24029                                 Name, Desc string
24030
24031                                 InvImg, WieldImg Texture
24032                                 WieldScale       [3]float32
24033
24034                                 StackMax uint16
24035
24036                                 Usable          bool
24037                                 CanPointLiquids bool
24038
24039                                 ToolCaps ToolCaps
24040
24041                                 Groups []Group
24042
24043                                 PlacePredict string
24044
24045                                 PlaceSnd, PlaceFailSnd SoundDef
24046
24047                                 PointRange float32
24048
24049                                 // Set index in Palette with "palette_index" item meta field,
24050                                 // this overrides Color.
24051                                 Palette Texture
24052                                 Color   color.NRGBA
24053
24054                                 // Texture overlays.
24055                                 InvOverlay, WieldOverlay Texture
24056
24057                                 ShortDesc string
24058                         }))(obj)).WieldImg).serialize(w)
24059                 }); err != nil {
24060                         if err == io.EOF {
24061                                 chk(io.EOF)
24062                         }
24063                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24064                 }
24065                 for local298 := range (*(*(struct {
24066                         Type ItemType
24067
24068                         Name, Desc string
24069
24070                         InvImg, WieldImg Texture
24071                         WieldScale       [3]float32
24072
24073                         StackMax uint16
24074
24075                         Usable          bool
24076                         CanPointLiquids bool
24077
24078                         ToolCaps ToolCaps
24079
24080                         Groups []Group
24081
24082                         PlacePredict string
24083
24084                         PlaceSnd, PlaceFailSnd SoundDef
24085
24086                         PointRange float32
24087
24088                         // Set index in Palette with "palette_index" item meta field,
24089                         // this overrides Color.
24090                         Palette Texture
24091                         Color   color.NRGBA
24092
24093                         // Texture overlays.
24094                         InvOverlay, WieldOverlay Texture
24095
24096                         ShortDesc string
24097                 }))(obj)).WieldScale {
24098                         {
24099                                 x := ((*(*(struct {
24100                                         Type ItemType
24101
24102                                         Name, Desc string
24103
24104                                         InvImg, WieldImg Texture
24105                                         WieldScale       [3]float32
24106
24107                                         StackMax uint16
24108
24109                                         Usable          bool
24110                                         CanPointLiquids bool
24111
24112                                         ToolCaps ToolCaps
24113
24114                                         Groups []Group
24115
24116                                         PlacePredict string
24117
24118                                         PlaceSnd, PlaceFailSnd SoundDef
24119
24120                                         PointRange float32
24121
24122                                         // Set index in Palette with "palette_index" item meta field,
24123                                         // this overrides Color.
24124                                         Palette Texture
24125                                         Color   color.NRGBA
24126
24127                                         // Texture overlays.
24128                                         InvOverlay, WieldOverlay Texture
24129
24130                                         ShortDesc string
24131                                 }))(obj)).WieldScale)[local298]
24132                                 write32(w, math.Float32bits(x))
24133                         }
24134                 }
24135                 {
24136                         x := (*(*(struct {
24137                                 Type ItemType
24138
24139                                 Name, Desc string
24140
24141                                 InvImg, WieldImg Texture
24142                                 WieldScale       [3]float32
24143
24144                                 StackMax uint16
24145
24146                                 Usable          bool
24147                                 CanPointLiquids bool
24148
24149                                 ToolCaps ToolCaps
24150
24151                                 Groups []Group
24152
24153                                 PlacePredict string
24154
24155                                 PlaceSnd, PlaceFailSnd SoundDef
24156
24157                                 PointRange float32
24158
24159                                 // Set index in Palette with "palette_index" item meta field,
24160                                 // this overrides Color.
24161                                 Palette Texture
24162                                 Color   color.NRGBA
24163
24164                                 // Texture overlays.
24165                                 InvOverlay, WieldOverlay Texture
24166
24167                                 ShortDesc string
24168                         }))(obj)).StackMax
24169                         write16(w, uint16(x))
24170                 }
24171                 {
24172                         x := (*(*(struct {
24173                                 Type ItemType
24174
24175                                 Name, Desc string
24176
24177                                 InvImg, WieldImg Texture
24178                                 WieldScale       [3]float32
24179
24180                                 StackMax uint16
24181
24182                                 Usable          bool
24183                                 CanPointLiquids bool
24184
24185                                 ToolCaps ToolCaps
24186
24187                                 Groups []Group
24188
24189                                 PlacePredict string
24190
24191                                 PlaceSnd, PlaceFailSnd SoundDef
24192
24193                                 PointRange float32
24194
24195                                 // Set index in Palette with "palette_index" item meta field,
24196                                 // this overrides Color.
24197                                 Palette Texture
24198                                 Color   color.NRGBA
24199
24200                                 // Texture overlays.
24201                                 InvOverlay, WieldOverlay Texture
24202
24203                                 ShortDesc string
24204                         }))(obj)).Usable
24205                         if x {
24206                                 write8(w, 1)
24207                         } else {
24208                                 write8(w, 0)
24209                         }
24210                 }
24211                 {
24212                         x := (*(*(struct {
24213                                 Type ItemType
24214
24215                                 Name, Desc string
24216
24217                                 InvImg, WieldImg Texture
24218                                 WieldScale       [3]float32
24219
24220                                 StackMax uint16
24221
24222                                 Usable          bool
24223                                 CanPointLiquids bool
24224
24225                                 ToolCaps ToolCaps
24226
24227                                 Groups []Group
24228
24229                                 PlacePredict string
24230
24231                                 PlaceSnd, PlaceFailSnd SoundDef
24232
24233                                 PointRange float32
24234
24235                                 // Set index in Palette with "palette_index" item meta field,
24236                                 // this overrides Color.
24237                                 Palette Texture
24238                                 Color   color.NRGBA
24239
24240                                 // Texture overlays.
24241                                 InvOverlay, WieldOverlay Texture
24242
24243                                 ShortDesc string
24244                         }))(obj)).CanPointLiquids
24245                         if x {
24246                                 write8(w, 1)
24247                         } else {
24248                                 write8(w, 0)
24249                         }
24250                 }
24251                 if err := pcall(func() {
24252                         ((*(*(struct {
24253                                 Type ItemType
24254
24255                                 Name, Desc string
24256
24257                                 InvImg, WieldImg Texture
24258                                 WieldScale       [3]float32
24259
24260                                 StackMax uint16
24261
24262                                 Usable          bool
24263                                 CanPointLiquids bool
24264
24265                                 ToolCaps ToolCaps
24266
24267                                 Groups []Group
24268
24269                                 PlacePredict string
24270
24271                                 PlaceSnd, PlaceFailSnd SoundDef
24272
24273                                 PointRange float32
24274
24275                                 // Set index in Palette with "palette_index" item meta field,
24276                                 // this overrides Color.
24277                                 Palette Texture
24278                                 Color   color.NRGBA
24279
24280                                 // Texture overlays.
24281                                 InvOverlay, WieldOverlay Texture
24282
24283                                 ShortDesc string
24284                         }))(obj)).ToolCaps).serialize(w)
24285                 }); err != nil {
24286                         if err == io.EOF {
24287                                 chk(io.EOF)
24288                         }
24289                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
24290                 }
24291                 if len(((*(*(struct {
24292                         Type ItemType
24293
24294                         Name, Desc string
24295
24296                         InvImg, WieldImg Texture
24297                         WieldScale       [3]float32
24298
24299                         StackMax uint16
24300
24301                         Usable          bool
24302                         CanPointLiquids bool
24303
24304                         ToolCaps ToolCaps
24305
24306                         Groups []Group
24307
24308                         PlacePredict string
24309
24310                         PlaceSnd, PlaceFailSnd SoundDef
24311
24312                         PointRange float32
24313
24314                         // Set index in Palette with "palette_index" item meta field,
24315                         // this overrides Color.
24316                         Palette Texture
24317                         Color   color.NRGBA
24318
24319                         // Texture overlays.
24320                         InvOverlay, WieldOverlay Texture
24321
24322                         ShortDesc string
24323                 }))(obj)).Groups)) > math.MaxUint16 {
24324                         chk(ErrTooLong)
24325                 }
24326                 {
24327                         x := uint16(len(((*(*(struct {
24328                                 Type ItemType
24329
24330                                 Name, Desc string
24331
24332                                 InvImg, WieldImg Texture
24333                                 WieldScale       [3]float32
24334
24335                                 StackMax uint16
24336
24337                                 Usable          bool
24338                                 CanPointLiquids bool
24339
24340                                 ToolCaps ToolCaps
24341
24342                                 Groups []Group
24343
24344                                 PlacePredict string
24345
24346                                 PlaceSnd, PlaceFailSnd SoundDef
24347
24348                                 PointRange float32
24349
24350                                 // Set index in Palette with "palette_index" item meta field,
24351                                 // this overrides Color.
24352                                 Palette Texture
24353                                 Color   color.NRGBA
24354
24355                                 // Texture overlays.
24356                                 InvOverlay, WieldOverlay Texture
24357
24358                                 ShortDesc string
24359                         }))(obj)).Groups)))
24360                         write16(w, uint16(x))
24361                 }
24362                 for local299 := range (*(*(struct {
24363                         Type ItemType
24364
24365                         Name, Desc string
24366
24367                         InvImg, WieldImg Texture
24368                         WieldScale       [3]float32
24369
24370                         StackMax uint16
24371
24372                         Usable          bool
24373                         CanPointLiquids bool
24374
24375                         ToolCaps ToolCaps
24376
24377                         Groups []Group
24378
24379                         PlacePredict string
24380
24381                         PlaceSnd, PlaceFailSnd SoundDef
24382
24383                         PointRange float32
24384
24385                         // Set index in Palette with "palette_index" item meta field,
24386                         // this overrides Color.
24387                         Palette Texture
24388                         Color   color.NRGBA
24389
24390                         // Texture overlays.
24391                         InvOverlay, WieldOverlay Texture
24392
24393                         ShortDesc string
24394                 }))(obj)).Groups {
24395                         if err := pcall(func() {
24396                                 (((*(*(struct {
24397                                         Type ItemType
24398
24399                                         Name, Desc string
24400
24401                                         InvImg, WieldImg Texture
24402                                         WieldScale       [3]float32
24403
24404                                         StackMax uint16
24405
24406                                         Usable          bool
24407                                         CanPointLiquids bool
24408
24409                                         ToolCaps ToolCaps
24410
24411                                         Groups []Group
24412
24413                                         PlacePredict string
24414
24415                                         PlaceSnd, PlaceFailSnd SoundDef
24416
24417                                         PointRange float32
24418
24419                                         // Set index in Palette with "palette_index" item meta field,
24420                                         // this overrides Color.
24421                                         Palette Texture
24422                                         Color   color.NRGBA
24423
24424                                         // Texture overlays.
24425                                         InvOverlay, WieldOverlay Texture
24426
24427                                         ShortDesc string
24428                                 }))(obj)).Groups)[local299]).serialize(w)
24429                         }); err != nil {
24430                                 if err == io.EOF {
24431                                         chk(io.EOF)
24432                                 }
24433                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
24434                         }
24435                 }
24436                 if len(([]byte((*(*(struct {
24437                         Type ItemType
24438
24439                         Name, Desc string
24440
24441                         InvImg, WieldImg Texture
24442                         WieldScale       [3]float32
24443
24444                         StackMax uint16
24445
24446                         Usable          bool
24447                         CanPointLiquids bool
24448
24449                         ToolCaps ToolCaps
24450
24451                         Groups []Group
24452
24453                         PlacePredict string
24454
24455                         PlaceSnd, PlaceFailSnd SoundDef
24456
24457                         PointRange float32
24458
24459                         // Set index in Palette with "palette_index" item meta field,
24460                         // this overrides Color.
24461                         Palette Texture
24462                         Color   color.NRGBA
24463
24464                         // Texture overlays.
24465                         InvOverlay, WieldOverlay Texture
24466
24467                         ShortDesc string
24468                 }))(obj)).PlacePredict))) > math.MaxUint16 {
24469                         chk(ErrTooLong)
24470                 }
24471                 {
24472                         x := uint16(len(([]byte((*(*(struct {
24473                                 Type ItemType
24474
24475                                 Name, Desc string
24476
24477                                 InvImg, WieldImg Texture
24478                                 WieldScale       [3]float32
24479
24480                                 StackMax uint16
24481
24482                                 Usable          bool
24483                                 CanPointLiquids bool
24484
24485                                 ToolCaps ToolCaps
24486
24487                                 Groups []Group
24488
24489                                 PlacePredict string
24490
24491                                 PlaceSnd, PlaceFailSnd SoundDef
24492
24493                                 PointRange float32
24494
24495                                 // Set index in Palette with "palette_index" item meta field,
24496                                 // this overrides Color.
24497                                 Palette Texture
24498                                 Color   color.NRGBA
24499
24500                                 // Texture overlays.
24501                                 InvOverlay, WieldOverlay Texture
24502
24503                                 ShortDesc string
24504                         }))(obj)).PlacePredict))))
24505                         write16(w, uint16(x))
24506                 }
24507                 {
24508                         _, err := w.Write(([]byte((*(*(struct {
24509                                 Type ItemType
24510
24511                                 Name, Desc string
24512
24513                                 InvImg, WieldImg Texture
24514                                 WieldScale       [3]float32
24515
24516                                 StackMax uint16
24517
24518                                 Usable          bool
24519                                 CanPointLiquids bool
24520
24521                                 ToolCaps ToolCaps
24522
24523                                 Groups []Group
24524
24525                                 PlacePredict string
24526
24527                                 PlaceSnd, PlaceFailSnd SoundDef
24528
24529                                 PointRange float32
24530
24531                                 // Set index in Palette with "palette_index" item meta field,
24532                                 // this overrides Color.
24533                                 Palette Texture
24534                                 Color   color.NRGBA
24535
24536                                 // Texture overlays.
24537                                 InvOverlay, WieldOverlay Texture
24538
24539                                 ShortDesc string
24540                         }))(obj)).PlacePredict))[:])
24541                         chk(err)
24542                 }
24543                 if err := pcall(func() {
24544                         ((*(*(struct {
24545                                 Type ItemType
24546
24547                                 Name, Desc string
24548
24549                                 InvImg, WieldImg Texture
24550                                 WieldScale       [3]float32
24551
24552                                 StackMax uint16
24553
24554                                 Usable          bool
24555                                 CanPointLiquids bool
24556
24557                                 ToolCaps ToolCaps
24558
24559                                 Groups []Group
24560
24561                                 PlacePredict string
24562
24563                                 PlaceSnd, PlaceFailSnd SoundDef
24564
24565                                 PointRange float32
24566
24567                                 // Set index in Palette with "palette_index" item meta field,
24568                                 // this overrides Color.
24569                                 Palette Texture
24570                                 Color   color.NRGBA
24571
24572                                 // Texture overlays.
24573                                 InvOverlay, WieldOverlay Texture
24574
24575                                 ShortDesc string
24576                         }))(obj)).PlaceSnd).serialize(w)
24577                 }); err != nil {
24578                         if err == io.EOF {
24579                                 chk(io.EOF)
24580                         }
24581                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
24582                 }
24583                 if err := pcall(func() {
24584                         ((*(*(struct {
24585                                 Type ItemType
24586
24587                                 Name, Desc string
24588
24589                                 InvImg, WieldImg Texture
24590                                 WieldScale       [3]float32
24591
24592                                 StackMax uint16
24593
24594                                 Usable          bool
24595                                 CanPointLiquids bool
24596
24597                                 ToolCaps ToolCaps
24598
24599                                 Groups []Group
24600
24601                                 PlacePredict string
24602
24603                                 PlaceSnd, PlaceFailSnd SoundDef
24604
24605                                 PointRange float32
24606
24607                                 // Set index in Palette with "palette_index" item meta field,
24608                                 // this overrides Color.
24609                                 Palette Texture
24610                                 Color   color.NRGBA
24611
24612                                 // Texture overlays.
24613                                 InvOverlay, WieldOverlay Texture
24614
24615                                 ShortDesc string
24616                         }))(obj)).PlaceFailSnd).serialize(w)
24617                 }); err != nil {
24618                         if err == io.EOF {
24619                                 chk(io.EOF)
24620                         }
24621                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
24622                 }
24623                 {
24624                         x := (*(*(struct {
24625                                 Type ItemType
24626
24627                                 Name, Desc string
24628
24629                                 InvImg, WieldImg Texture
24630                                 WieldScale       [3]float32
24631
24632                                 StackMax uint16
24633
24634                                 Usable          bool
24635                                 CanPointLiquids bool
24636
24637                                 ToolCaps ToolCaps
24638
24639                                 Groups []Group
24640
24641                                 PlacePredict string
24642
24643                                 PlaceSnd, PlaceFailSnd SoundDef
24644
24645                                 PointRange float32
24646
24647                                 // Set index in Palette with "palette_index" item meta field,
24648                                 // this overrides Color.
24649                                 Palette Texture
24650                                 Color   color.NRGBA
24651
24652                                 // Texture overlays.
24653                                 InvOverlay, WieldOverlay Texture
24654
24655                                 ShortDesc string
24656                         }))(obj)).PointRange
24657                         write32(w, math.Float32bits(x))
24658                 }
24659                 if err := pcall(func() {
24660                         ((*(*(struct {
24661                                 Type ItemType
24662
24663                                 Name, Desc string
24664
24665                                 InvImg, WieldImg Texture
24666                                 WieldScale       [3]float32
24667
24668                                 StackMax uint16
24669
24670                                 Usable          bool
24671                                 CanPointLiquids bool
24672
24673                                 ToolCaps ToolCaps
24674
24675                                 Groups []Group
24676
24677                                 PlacePredict string
24678
24679                                 PlaceSnd, PlaceFailSnd SoundDef
24680
24681                                 PointRange float32
24682
24683                                 // Set index in Palette with "palette_index" item meta field,
24684                                 // this overrides Color.
24685                                 Palette Texture
24686                                 Color   color.NRGBA
24687
24688                                 // Texture overlays.
24689                                 InvOverlay, WieldOverlay Texture
24690
24691                                 ShortDesc string
24692                         }))(obj)).Palette).serialize(w)
24693                 }); err != nil {
24694                         if err == io.EOF {
24695                                 chk(io.EOF)
24696                         }
24697                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24698                 }
24699                 {
24700                         x := (*(*(struct {
24701                                 Type ItemType
24702
24703                                 Name, Desc string
24704
24705                                 InvImg, WieldImg Texture
24706                                 WieldScale       [3]float32
24707
24708                                 StackMax uint16
24709
24710                                 Usable          bool
24711                                 CanPointLiquids bool
24712
24713                                 ToolCaps ToolCaps
24714
24715                                 Groups []Group
24716
24717                                 PlacePredict string
24718
24719                                 PlaceSnd, PlaceFailSnd SoundDef
24720
24721                                 PointRange float32
24722
24723                                 // Set index in Palette with "palette_index" item meta field,
24724                                 // this overrides Color.
24725                                 Palette Texture
24726                                 Color   color.NRGBA
24727
24728                                 // Texture overlays.
24729                                 InvOverlay, WieldOverlay Texture
24730
24731                                 ShortDesc string
24732                         }))(obj)).Color
24733                         w.Write([]byte{x.A, x.R, x.G, x.B})
24734                 }
24735                 if err := pcall(func() {
24736                         ((*(*(struct {
24737                                 Type ItemType
24738
24739                                 Name, Desc string
24740
24741                                 InvImg, WieldImg Texture
24742                                 WieldScale       [3]float32
24743
24744                                 StackMax uint16
24745
24746                                 Usable          bool
24747                                 CanPointLiquids bool
24748
24749                                 ToolCaps ToolCaps
24750
24751                                 Groups []Group
24752
24753                                 PlacePredict string
24754
24755                                 PlaceSnd, PlaceFailSnd SoundDef
24756
24757                                 PointRange float32
24758
24759                                 // Set index in Palette with "palette_index" item meta field,
24760                                 // this overrides Color.
24761                                 Palette Texture
24762                                 Color   color.NRGBA
24763
24764                                 // Texture overlays.
24765                                 InvOverlay, WieldOverlay Texture
24766
24767                                 ShortDesc string
24768                         }))(obj)).InvOverlay).serialize(w)
24769                 }); err != nil {
24770                         if err == io.EOF {
24771                                 chk(io.EOF)
24772                         }
24773                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24774                 }
24775                 if err := pcall(func() {
24776                         ((*(*(struct {
24777                                 Type ItemType
24778
24779                                 Name, Desc string
24780
24781                                 InvImg, WieldImg Texture
24782                                 WieldScale       [3]float32
24783
24784                                 StackMax uint16
24785
24786                                 Usable          bool
24787                                 CanPointLiquids bool
24788
24789                                 ToolCaps ToolCaps
24790
24791                                 Groups []Group
24792
24793                                 PlacePredict string
24794
24795                                 PlaceSnd, PlaceFailSnd SoundDef
24796
24797                                 PointRange float32
24798
24799                                 // Set index in Palette with "palette_index" item meta field,
24800                                 // this overrides Color.
24801                                 Palette Texture
24802                                 Color   color.NRGBA
24803
24804                                 // Texture overlays.
24805                                 InvOverlay, WieldOverlay Texture
24806
24807                                 ShortDesc string
24808                         }))(obj)).WieldOverlay).serialize(w)
24809                 }); err != nil {
24810                         if err == io.EOF {
24811                                 chk(io.EOF)
24812                         }
24813                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24814                 }
24815                 if len(([]byte((*(*(struct {
24816                         Type ItemType
24817
24818                         Name, Desc string
24819
24820                         InvImg, WieldImg Texture
24821                         WieldScale       [3]float32
24822
24823                         StackMax uint16
24824
24825                         Usable          bool
24826                         CanPointLiquids bool
24827
24828                         ToolCaps ToolCaps
24829
24830                         Groups []Group
24831
24832                         PlacePredict string
24833
24834                         PlaceSnd, PlaceFailSnd SoundDef
24835
24836                         PointRange float32
24837
24838                         // Set index in Palette with "palette_index" item meta field,
24839                         // this overrides Color.
24840                         Palette Texture
24841                         Color   color.NRGBA
24842
24843                         // Texture overlays.
24844                         InvOverlay, WieldOverlay Texture
24845
24846                         ShortDesc string
24847                 }))(obj)).ShortDesc))) > math.MaxUint16 {
24848                         chk(ErrTooLong)
24849                 }
24850                 {
24851                         x := uint16(len(([]byte((*(*(struct {
24852                                 Type ItemType
24853
24854                                 Name, Desc string
24855
24856                                 InvImg, WieldImg Texture
24857                                 WieldScale       [3]float32
24858
24859                                 StackMax uint16
24860
24861                                 Usable          bool
24862                                 CanPointLiquids bool
24863
24864                                 ToolCaps ToolCaps
24865
24866                                 Groups []Group
24867
24868                                 PlacePredict string
24869
24870                                 PlaceSnd, PlaceFailSnd SoundDef
24871
24872                                 PointRange float32
24873
24874                                 // Set index in Palette with "palette_index" item meta field,
24875                                 // this overrides Color.
24876                                 Palette Texture
24877                                 Color   color.NRGBA
24878
24879                                 // Texture overlays.
24880                                 InvOverlay, WieldOverlay Texture
24881
24882                                 ShortDesc string
24883                         }))(obj)).ShortDesc))))
24884                         write16(w, uint16(x))
24885                 }
24886                 {
24887                         _, err := w.Write(([]byte((*(*(struct {
24888                                 Type ItemType
24889
24890                                 Name, Desc string
24891
24892                                 InvImg, WieldImg Texture
24893                                 WieldScale       [3]float32
24894
24895                                 StackMax uint16
24896
24897                                 Usable          bool
24898                                 CanPointLiquids bool
24899
24900                                 ToolCaps ToolCaps
24901
24902                                 Groups []Group
24903
24904                                 PlacePredict string
24905
24906                                 PlaceSnd, PlaceFailSnd SoundDef
24907
24908                                 PointRange float32
24909
24910                                 // Set index in Palette with "palette_index" item meta field,
24911                                 // this overrides Color.
24912                                 Palette Texture
24913                                 Color   color.NRGBA
24914
24915                                 // Texture overlays.
24916                                 InvOverlay, WieldOverlay Texture
24917
24918                                 ShortDesc string
24919                         }))(obj)).ShortDesc))[:])
24920                         chk(err)
24921                 }
24922                 {
24923                         buf := w
24924                         w := ow
24925                         if len((buf.Bytes())) > math.MaxUint16 {
24926                                 chk(ErrTooLong)
24927                         }
24928                         {
24929                                 x := uint16(len((buf.Bytes())))
24930                                 write16(w, uint16(x))
24931                         }
24932                         {
24933                                 _, err := w.Write((buf.Bytes())[:])
24934                                 chk(err)
24935                         }
24936                 }
24937         }
24938 }
24939
24940 func (obj *ItemDef) deserialize(r io.Reader) {
24941         {
24942                 var n uint16
24943                 {
24944                         p := &n
24945                         *p = read16(r)
24946                 }
24947                 r := &io.LimitedReader{R: r, N: int64(n)}
24948                 {
24949                         var local300 uint8
24950                         local301 := uint8(6)
24951                         {
24952                                 p := &local300
24953                                 *p = read8(r)
24954                         }
24955                         if local300 != local301 {
24956                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local300))
24957                         }
24958                 }
24959                 if err := pcall(func() {
24960                         ((*(*(struct {
24961                                 Type ItemType
24962
24963                                 Name, Desc string
24964
24965                                 InvImg, WieldImg Texture
24966                                 WieldScale       [3]float32
24967
24968                                 StackMax uint16
24969
24970                                 Usable          bool
24971                                 CanPointLiquids bool
24972
24973                                 ToolCaps ToolCaps
24974
24975                                 Groups []Group
24976
24977                                 PlacePredict string
24978
24979                                 PlaceSnd, PlaceFailSnd SoundDef
24980
24981                                 PointRange float32
24982
24983                                 // Set index in Palette with "palette_index" item meta field,
24984                                 // this overrides Color.
24985                                 Palette Texture
24986                                 Color   color.NRGBA
24987
24988                                 // Texture overlays.
24989                                 InvOverlay, WieldOverlay Texture
24990
24991                                 ShortDesc string
24992                         }))(obj)).Type).deserialize(r)
24993                 }); err != nil {
24994                         if err == io.EOF {
24995                                 chk(io.EOF)
24996                         }
24997                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
24998                 }
24999                 var local302 []uint8
25000                 var local303 uint16
25001                 {
25002                         p := &local303
25003                         *p = read16(r)
25004                 }
25005                 (local302) = make([]uint8, local303)
25006                 {
25007                         _, err := io.ReadFull(r, (local302)[:])
25008                         chk(err)
25009                 }
25010                 ((*(*(struct {
25011                         Type ItemType
25012
25013                         Name, Desc string
25014
25015                         InvImg, WieldImg Texture
25016                         WieldScale       [3]float32
25017
25018                         StackMax uint16
25019
25020                         Usable          bool
25021                         CanPointLiquids bool
25022
25023                         ToolCaps ToolCaps
25024
25025                         Groups []Group
25026
25027                         PlacePredict string
25028
25029                         PlaceSnd, PlaceFailSnd SoundDef
25030
25031                         PointRange float32
25032
25033                         // Set index in Palette with "palette_index" item meta field,
25034                         // this overrides Color.
25035                         Palette Texture
25036                         Color   color.NRGBA
25037
25038                         // Texture overlays.
25039                         InvOverlay, WieldOverlay Texture
25040
25041                         ShortDesc string
25042                 }))(obj)).Name) = string(local302)
25043                 var local304 []uint8
25044                 var local305 uint16
25045                 {
25046                         p := &local305
25047                         *p = read16(r)
25048                 }
25049                 (local304) = make([]uint8, local305)
25050                 {
25051                         _, err := io.ReadFull(r, (local304)[:])
25052                         chk(err)
25053                 }
25054                 ((*(*(struct {
25055                         Type ItemType
25056
25057                         Name, Desc string
25058
25059                         InvImg, WieldImg Texture
25060                         WieldScale       [3]float32
25061
25062                         StackMax uint16
25063
25064                         Usable          bool
25065                         CanPointLiquids bool
25066
25067                         ToolCaps ToolCaps
25068
25069                         Groups []Group
25070
25071                         PlacePredict string
25072
25073                         PlaceSnd, PlaceFailSnd SoundDef
25074
25075                         PointRange float32
25076
25077                         // Set index in Palette with "palette_index" item meta field,
25078                         // this overrides Color.
25079                         Palette Texture
25080                         Color   color.NRGBA
25081
25082                         // Texture overlays.
25083                         InvOverlay, WieldOverlay Texture
25084
25085                         ShortDesc string
25086                 }))(obj)).Desc) = string(local304)
25087                 if err := pcall(func() {
25088                         ((*(*(struct {
25089                                 Type ItemType
25090
25091                                 Name, Desc string
25092
25093                                 InvImg, WieldImg Texture
25094                                 WieldScale       [3]float32
25095
25096                                 StackMax uint16
25097
25098                                 Usable          bool
25099                                 CanPointLiquids bool
25100
25101                                 ToolCaps ToolCaps
25102
25103                                 Groups []Group
25104
25105                                 PlacePredict string
25106
25107                                 PlaceSnd, PlaceFailSnd SoundDef
25108
25109                                 PointRange float32
25110
25111                                 // Set index in Palette with "palette_index" item meta field,
25112                                 // this overrides Color.
25113                                 Palette Texture
25114                                 Color   color.NRGBA
25115
25116                                 // Texture overlays.
25117                                 InvOverlay, WieldOverlay Texture
25118
25119                                 ShortDesc string
25120                         }))(obj)).InvImg).deserialize(r)
25121                 }); err != nil {
25122                         if err == io.EOF {
25123                                 chk(io.EOF)
25124                         }
25125                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25126                 }
25127                 if err := pcall(func() {
25128                         ((*(*(struct {
25129                                 Type ItemType
25130
25131                                 Name, Desc string
25132
25133                                 InvImg, WieldImg Texture
25134                                 WieldScale       [3]float32
25135
25136                                 StackMax uint16
25137
25138                                 Usable          bool
25139                                 CanPointLiquids bool
25140
25141                                 ToolCaps ToolCaps
25142
25143                                 Groups []Group
25144
25145                                 PlacePredict string
25146
25147                                 PlaceSnd, PlaceFailSnd SoundDef
25148
25149                                 PointRange float32
25150
25151                                 // Set index in Palette with "palette_index" item meta field,
25152                                 // this overrides Color.
25153                                 Palette Texture
25154                                 Color   color.NRGBA
25155
25156                                 // Texture overlays.
25157                                 InvOverlay, WieldOverlay Texture
25158
25159                                 ShortDesc string
25160                         }))(obj)).WieldImg).deserialize(r)
25161                 }); err != nil {
25162                         if err == io.EOF {
25163                                 chk(io.EOF)
25164                         }
25165                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25166                 }
25167                 for local306 := range (*(*(struct {
25168                         Type ItemType
25169
25170                         Name, Desc string
25171
25172                         InvImg, WieldImg Texture
25173                         WieldScale       [3]float32
25174
25175                         StackMax uint16
25176
25177                         Usable          bool
25178                         CanPointLiquids bool
25179
25180                         ToolCaps ToolCaps
25181
25182                         Groups []Group
25183
25184                         PlacePredict string
25185
25186                         PlaceSnd, PlaceFailSnd SoundDef
25187
25188                         PointRange float32
25189
25190                         // Set index in Palette with "palette_index" item meta field,
25191                         // this overrides Color.
25192                         Palette Texture
25193                         Color   color.NRGBA
25194
25195                         // Texture overlays.
25196                         InvOverlay, WieldOverlay Texture
25197
25198                         ShortDesc string
25199                 }))(obj)).WieldScale {
25200                         {
25201                                 p := &((*(*(struct {
25202                                         Type ItemType
25203
25204                                         Name, Desc string
25205
25206                                         InvImg, WieldImg Texture
25207                                         WieldScale       [3]float32
25208
25209                                         StackMax uint16
25210
25211                                         Usable          bool
25212                                         CanPointLiquids bool
25213
25214                                         ToolCaps ToolCaps
25215
25216                                         Groups []Group
25217
25218                                         PlacePredict string
25219
25220                                         PlaceSnd, PlaceFailSnd SoundDef
25221
25222                                         PointRange float32
25223
25224                                         // Set index in Palette with "palette_index" item meta field,
25225                                         // this overrides Color.
25226                                         Palette Texture
25227                                         Color   color.NRGBA
25228
25229                                         // Texture overlays.
25230                                         InvOverlay, WieldOverlay Texture
25231
25232                                         ShortDesc string
25233                                 }))(obj)).WieldScale)[local306]
25234                                 *p = math.Float32frombits(read32(r))
25235                         }
25236                 }
25237                 {
25238                         p := &(*(*(struct {
25239                                 Type ItemType
25240
25241                                 Name, Desc string
25242
25243                                 InvImg, WieldImg Texture
25244                                 WieldScale       [3]float32
25245
25246                                 StackMax uint16
25247
25248                                 Usable          bool
25249                                 CanPointLiquids bool
25250
25251                                 ToolCaps ToolCaps
25252
25253                                 Groups []Group
25254
25255                                 PlacePredict string
25256
25257                                 PlaceSnd, PlaceFailSnd SoundDef
25258
25259                                 PointRange float32
25260
25261                                 // Set index in Palette with "palette_index" item meta field,
25262                                 // this overrides Color.
25263                                 Palette Texture
25264                                 Color   color.NRGBA
25265
25266                                 // Texture overlays.
25267                                 InvOverlay, WieldOverlay Texture
25268
25269                                 ShortDesc string
25270                         }))(obj)).StackMax
25271                         *p = read16(r)
25272                 }
25273                 {
25274                         p := &(*(*(struct {
25275                                 Type ItemType
25276
25277                                 Name, Desc string
25278
25279                                 InvImg, WieldImg Texture
25280                                 WieldScale       [3]float32
25281
25282                                 StackMax uint16
25283
25284                                 Usable          bool
25285                                 CanPointLiquids bool
25286
25287                                 ToolCaps ToolCaps
25288
25289                                 Groups []Group
25290
25291                                 PlacePredict string
25292
25293                                 PlaceSnd, PlaceFailSnd SoundDef
25294
25295                                 PointRange float32
25296
25297                                 // Set index in Palette with "palette_index" item meta field,
25298                                 // this overrides Color.
25299                                 Palette Texture
25300                                 Color   color.NRGBA
25301
25302                                 // Texture overlays.
25303                                 InvOverlay, WieldOverlay Texture
25304
25305                                 ShortDesc string
25306                         }))(obj)).Usable
25307                         switch n := read8(r); n {
25308                         case 0:
25309                                 *p = false
25310                         case 1:
25311                                 *p = true
25312                         default:
25313                                 chk(fmt.Errorf("invalid bool: %d", n))
25314                         }
25315                 }
25316                 {
25317                         p := &(*(*(struct {
25318                                 Type ItemType
25319
25320                                 Name, Desc string
25321
25322                                 InvImg, WieldImg Texture
25323                                 WieldScale       [3]float32
25324
25325                                 StackMax uint16
25326
25327                                 Usable          bool
25328                                 CanPointLiquids bool
25329
25330                                 ToolCaps ToolCaps
25331
25332                                 Groups []Group
25333
25334                                 PlacePredict string
25335
25336                                 PlaceSnd, PlaceFailSnd SoundDef
25337
25338                                 PointRange float32
25339
25340                                 // Set index in Palette with "palette_index" item meta field,
25341                                 // this overrides Color.
25342                                 Palette Texture
25343                                 Color   color.NRGBA
25344
25345                                 // Texture overlays.
25346                                 InvOverlay, WieldOverlay Texture
25347
25348                                 ShortDesc string
25349                         }))(obj)).CanPointLiquids
25350                         switch n := read8(r); n {
25351                         case 0:
25352                                 *p = false
25353                         case 1:
25354                                 *p = true
25355                         default:
25356                                 chk(fmt.Errorf("invalid bool: %d", n))
25357                         }
25358                 }
25359                 if err := pcall(func() {
25360                         ((*(*(struct {
25361                                 Type ItemType
25362
25363                                 Name, Desc string
25364
25365                                 InvImg, WieldImg Texture
25366                                 WieldScale       [3]float32
25367
25368                                 StackMax uint16
25369
25370                                 Usable          bool
25371                                 CanPointLiquids bool
25372
25373                                 ToolCaps ToolCaps
25374
25375                                 Groups []Group
25376
25377                                 PlacePredict string
25378
25379                                 PlaceSnd, PlaceFailSnd SoundDef
25380
25381                                 PointRange float32
25382
25383                                 // Set index in Palette with "palette_index" item meta field,
25384                                 // this overrides Color.
25385                                 Palette Texture
25386                                 Color   color.NRGBA
25387
25388                                 // Texture overlays.
25389                                 InvOverlay, WieldOverlay Texture
25390
25391                                 ShortDesc string
25392                         }))(obj)).ToolCaps).deserialize(r)
25393                 }); err != nil {
25394                         if err == io.EOF {
25395                                 chk(io.EOF)
25396                         }
25397                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
25398                 }
25399                 var local307 uint16
25400                 {
25401                         p := &local307
25402                         *p = read16(r)
25403                 }
25404                 ((*(*(struct {
25405                         Type ItemType
25406
25407                         Name, Desc string
25408
25409                         InvImg, WieldImg Texture
25410                         WieldScale       [3]float32
25411
25412                         StackMax uint16
25413
25414                         Usable          bool
25415                         CanPointLiquids bool
25416
25417                         ToolCaps ToolCaps
25418
25419                         Groups []Group
25420
25421                         PlacePredict string
25422
25423                         PlaceSnd, PlaceFailSnd SoundDef
25424
25425                         PointRange float32
25426
25427                         // Set index in Palette with "palette_index" item meta field,
25428                         // this overrides Color.
25429                         Palette Texture
25430                         Color   color.NRGBA
25431
25432                         // Texture overlays.
25433                         InvOverlay, WieldOverlay Texture
25434
25435                         ShortDesc string
25436                 }))(obj)).Groups) = make([]Group, local307)
25437                 for local308 := range (*(*(struct {
25438                         Type ItemType
25439
25440                         Name, Desc string
25441
25442                         InvImg, WieldImg Texture
25443                         WieldScale       [3]float32
25444
25445                         StackMax uint16
25446
25447                         Usable          bool
25448                         CanPointLiquids bool
25449
25450                         ToolCaps ToolCaps
25451
25452                         Groups []Group
25453
25454                         PlacePredict string
25455
25456                         PlaceSnd, PlaceFailSnd SoundDef
25457
25458                         PointRange float32
25459
25460                         // Set index in Palette with "palette_index" item meta field,
25461                         // this overrides Color.
25462                         Palette Texture
25463                         Color   color.NRGBA
25464
25465                         // Texture overlays.
25466                         InvOverlay, WieldOverlay Texture
25467
25468                         ShortDesc string
25469                 }))(obj)).Groups {
25470                         if err := pcall(func() {
25471                                 (((*(*(struct {
25472                                         Type ItemType
25473
25474                                         Name, Desc string
25475
25476                                         InvImg, WieldImg Texture
25477                                         WieldScale       [3]float32
25478
25479                                         StackMax uint16
25480
25481                                         Usable          bool
25482                                         CanPointLiquids bool
25483
25484                                         ToolCaps ToolCaps
25485
25486                                         Groups []Group
25487
25488                                         PlacePredict string
25489
25490                                         PlaceSnd, PlaceFailSnd SoundDef
25491
25492                                         PointRange float32
25493
25494                                         // Set index in Palette with "palette_index" item meta field,
25495                                         // this overrides Color.
25496                                         Palette Texture
25497                                         Color   color.NRGBA
25498
25499                                         // Texture overlays.
25500                                         InvOverlay, WieldOverlay Texture
25501
25502                                         ShortDesc string
25503                                 }))(obj)).Groups)[local308]).deserialize(r)
25504                         }); err != nil {
25505                                 if err == io.EOF {
25506                                         chk(io.EOF)
25507                                 }
25508                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
25509                         }
25510                 }
25511                 var local309 []uint8
25512                 var local310 uint16
25513                 {
25514                         p := &local310
25515                         *p = read16(r)
25516                 }
25517                 (local309) = make([]uint8, local310)
25518                 {
25519                         _, err := io.ReadFull(r, (local309)[:])
25520                         chk(err)
25521                 }
25522                 ((*(*(struct {
25523                         Type ItemType
25524
25525                         Name, Desc string
25526
25527                         InvImg, WieldImg Texture
25528                         WieldScale       [3]float32
25529
25530                         StackMax uint16
25531
25532                         Usable          bool
25533                         CanPointLiquids bool
25534
25535                         ToolCaps ToolCaps
25536
25537                         Groups []Group
25538
25539                         PlacePredict string
25540
25541                         PlaceSnd, PlaceFailSnd SoundDef
25542
25543                         PointRange float32
25544
25545                         // Set index in Palette with "palette_index" item meta field,
25546                         // this overrides Color.
25547                         Palette Texture
25548                         Color   color.NRGBA
25549
25550                         // Texture overlays.
25551                         InvOverlay, WieldOverlay Texture
25552
25553                         ShortDesc string
25554                 }))(obj)).PlacePredict) = string(local309)
25555                 if err := pcall(func() {
25556                         ((*(*(struct {
25557                                 Type ItemType
25558
25559                                 Name, Desc string
25560
25561                                 InvImg, WieldImg Texture
25562                                 WieldScale       [3]float32
25563
25564                                 StackMax uint16
25565
25566                                 Usable          bool
25567                                 CanPointLiquids bool
25568
25569                                 ToolCaps ToolCaps
25570
25571                                 Groups []Group
25572
25573                                 PlacePredict string
25574
25575                                 PlaceSnd, PlaceFailSnd SoundDef
25576
25577                                 PointRange float32
25578
25579                                 // Set index in Palette with "palette_index" item meta field,
25580                                 // this overrides Color.
25581                                 Palette Texture
25582                                 Color   color.NRGBA
25583
25584                                 // Texture overlays.
25585                                 InvOverlay, WieldOverlay Texture
25586
25587                                 ShortDesc string
25588                         }))(obj)).PlaceSnd).deserialize(r)
25589                 }); err != nil {
25590                         if err == io.EOF {
25591                                 chk(io.EOF)
25592                         }
25593                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25594                 }
25595                 if err := pcall(func() {
25596                         ((*(*(struct {
25597                                 Type ItemType
25598
25599                                 Name, Desc string
25600
25601                                 InvImg, WieldImg Texture
25602                                 WieldScale       [3]float32
25603
25604                                 StackMax uint16
25605
25606                                 Usable          bool
25607                                 CanPointLiquids bool
25608
25609                                 ToolCaps ToolCaps
25610
25611                                 Groups []Group
25612
25613                                 PlacePredict string
25614
25615                                 PlaceSnd, PlaceFailSnd SoundDef
25616
25617                                 PointRange float32
25618
25619                                 // Set index in Palette with "palette_index" item meta field,
25620                                 // this overrides Color.
25621                                 Palette Texture
25622                                 Color   color.NRGBA
25623
25624                                 // Texture overlays.
25625                                 InvOverlay, WieldOverlay Texture
25626
25627                                 ShortDesc string
25628                         }))(obj)).PlaceFailSnd).deserialize(r)
25629                 }); err != nil {
25630                         if err == io.EOF {
25631                                 chk(io.EOF)
25632                         }
25633                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25634                 }
25635                 {
25636                         p := &(*(*(struct {
25637                                 Type ItemType
25638
25639                                 Name, Desc string
25640
25641                                 InvImg, WieldImg Texture
25642                                 WieldScale       [3]float32
25643
25644                                 StackMax uint16
25645
25646                                 Usable          bool
25647                                 CanPointLiquids bool
25648
25649                                 ToolCaps ToolCaps
25650
25651                                 Groups []Group
25652
25653                                 PlacePredict string
25654
25655                                 PlaceSnd, PlaceFailSnd SoundDef
25656
25657                                 PointRange float32
25658
25659                                 // Set index in Palette with "palette_index" item meta field,
25660                                 // this overrides Color.
25661                                 Palette Texture
25662                                 Color   color.NRGBA
25663
25664                                 // Texture overlays.
25665                                 InvOverlay, WieldOverlay Texture
25666
25667                                 ShortDesc string
25668                         }))(obj)).PointRange
25669                         *p = math.Float32frombits(read32(r))
25670                 }
25671                 if err := pcall(func() {
25672                         ((*(*(struct {
25673                                 Type ItemType
25674
25675                                 Name, Desc string
25676
25677                                 InvImg, WieldImg Texture
25678                                 WieldScale       [3]float32
25679
25680                                 StackMax uint16
25681
25682                                 Usable          bool
25683                                 CanPointLiquids bool
25684
25685                                 ToolCaps ToolCaps
25686
25687                                 Groups []Group
25688
25689                                 PlacePredict string
25690
25691                                 PlaceSnd, PlaceFailSnd SoundDef
25692
25693                                 PointRange float32
25694
25695                                 // Set index in Palette with "palette_index" item meta field,
25696                                 // this overrides Color.
25697                                 Palette Texture
25698                                 Color   color.NRGBA
25699
25700                                 // Texture overlays.
25701                                 InvOverlay, WieldOverlay Texture
25702
25703                                 ShortDesc string
25704                         }))(obj)).Palette).deserialize(r)
25705                 }); err != nil {
25706                         if err == io.EOF {
25707                                 chk(io.EOF)
25708                         }
25709                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25710                 }
25711                 {
25712                         p := &(*(*(struct {
25713                                 Type ItemType
25714
25715                                 Name, Desc string
25716
25717                                 InvImg, WieldImg Texture
25718                                 WieldScale       [3]float32
25719
25720                                 StackMax uint16
25721
25722                                 Usable          bool
25723                                 CanPointLiquids bool
25724
25725                                 ToolCaps ToolCaps
25726
25727                                 Groups []Group
25728
25729                                 PlacePredict string
25730
25731                                 PlaceSnd, PlaceFailSnd SoundDef
25732
25733                                 PointRange float32
25734
25735                                 // Set index in Palette with "palette_index" item meta field,
25736                                 // this overrides Color.
25737                                 Palette Texture
25738                                 Color   color.NRGBA
25739
25740                                 // Texture overlays.
25741                                 InvOverlay, WieldOverlay Texture
25742
25743                                 ShortDesc string
25744                         }))(obj)).Color
25745                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
25746                 }
25747                 if err := pcall(func() {
25748                         ((*(*(struct {
25749                                 Type ItemType
25750
25751                                 Name, Desc string
25752
25753                                 InvImg, WieldImg Texture
25754                                 WieldScale       [3]float32
25755
25756                                 StackMax uint16
25757
25758                                 Usable          bool
25759                                 CanPointLiquids bool
25760
25761                                 ToolCaps ToolCaps
25762
25763                                 Groups []Group
25764
25765                                 PlacePredict string
25766
25767                                 PlaceSnd, PlaceFailSnd SoundDef
25768
25769                                 PointRange float32
25770
25771                                 // Set index in Palette with "palette_index" item meta field,
25772                                 // this overrides Color.
25773                                 Palette Texture
25774                                 Color   color.NRGBA
25775
25776                                 // Texture overlays.
25777                                 InvOverlay, WieldOverlay Texture
25778
25779                                 ShortDesc string
25780                         }))(obj)).InvOverlay).deserialize(r)
25781                 }); err != nil {
25782                         if err == io.EOF {
25783                                 chk(io.EOF)
25784                         }
25785                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25786                 }
25787                 if err := pcall(func() {
25788                         ((*(*(struct {
25789                                 Type ItemType
25790
25791                                 Name, Desc string
25792
25793                                 InvImg, WieldImg Texture
25794                                 WieldScale       [3]float32
25795
25796                                 StackMax uint16
25797
25798                                 Usable          bool
25799                                 CanPointLiquids bool
25800
25801                                 ToolCaps ToolCaps
25802
25803                                 Groups []Group
25804
25805                                 PlacePredict string
25806
25807                                 PlaceSnd, PlaceFailSnd SoundDef
25808
25809                                 PointRange float32
25810
25811                                 // Set index in Palette with "palette_index" item meta field,
25812                                 // this overrides Color.
25813                                 Palette Texture
25814                                 Color   color.NRGBA
25815
25816                                 // Texture overlays.
25817                                 InvOverlay, WieldOverlay Texture
25818
25819                                 ShortDesc string
25820                         }))(obj)).WieldOverlay).deserialize(r)
25821                 }); err != nil {
25822                         if err == io.EOF {
25823                                 chk(io.EOF)
25824                         }
25825                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25826                 }
25827                 var local311 []uint8
25828                 var local312 uint16
25829                 {
25830                         p := &local312
25831                         *p = read16(r)
25832                 }
25833                 (local311) = make([]uint8, local312)
25834                 {
25835                         _, err := io.ReadFull(r, (local311)[:])
25836                         chk(err)
25837                 }
25838                 ((*(*(struct {
25839                         Type ItemType
25840
25841                         Name, Desc string
25842
25843                         InvImg, WieldImg Texture
25844                         WieldScale       [3]float32
25845
25846                         StackMax uint16
25847
25848                         Usable          bool
25849                         CanPointLiquids bool
25850
25851                         ToolCaps ToolCaps
25852
25853                         Groups []Group
25854
25855                         PlacePredict string
25856
25857                         PlaceSnd, PlaceFailSnd SoundDef
25858
25859                         PointRange float32
25860
25861                         // Set index in Palette with "palette_index" item meta field,
25862                         // this overrides Color.
25863                         Palette Texture
25864                         Color   color.NRGBA
25865
25866                         // Texture overlays.
25867                         InvOverlay, WieldOverlay Texture
25868
25869                         ShortDesc string
25870                 }))(obj)).ShortDesc) = string(local311)
25871                 if r.N > 0 {
25872                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
25873                 }
25874         }
25875 }
25876
25877 func (obj *SoundSrcType) serialize(w io.Writer) {
25878         {
25879                 x := *(*(uint8))(obj)
25880                 write8(w, uint8(x))
25881         }
25882 }
25883
25884 func (obj *SoundSrcType) deserialize(r io.Reader) {
25885         {
25886                 p := &*(*(uint8))(obj)
25887                 *p = read8(r)
25888         }
25889 }
25890
25891 func (obj *TileAnim) serialize(w io.Writer) {
25892         if err := pcall(func() {
25893                 ((*(*(struct {
25894                         Type AnimType
25895
25896                         //mt:if %s.Type == SpriteSheetAnim
25897                         AspectRatio [2]uint8
25898
25899                         //mt:if %s.Type == VerticalFrameAnim
25900                         NFrames [2]uint16
25901
25902                         //mt:if %s.Type != NoAnim
25903                         Duration float32 // in seconds
25904
25905                 }))(obj)).Type).serialize(w)
25906         }); err != nil {
25907                 if err == io.EOF {
25908                         chk(io.EOF)
25909                 }
25910                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
25911         }
25912         if !((*(*(struct {
25913                 Type AnimType
25914
25915                 //mt:if %s.Type == SpriteSheetAnim
25916                 AspectRatio [2]uint8
25917
25918                 //mt:if %s.Type == VerticalFrameAnim
25919                 NFrames [2]uint16
25920
25921                 //mt:if %s.Type != NoAnim
25922                 Duration float32 // in seconds
25923
25924         }))(obj)).Type < maxAnim) {
25925                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25926         }
25927         if (*(*(struct {
25928                 Type AnimType
25929
25930                 //mt:if %s.Type == SpriteSheetAnim
25931                 AspectRatio [2]uint8
25932
25933                 //mt:if %s.Type == VerticalFrameAnim
25934                 NFrames [2]uint16
25935
25936                 //mt:if %s.Type != NoAnim
25937                 Duration float32 // in seconds
25938
25939         }))(obj)).Type == SpriteSheetAnim {
25940                 {
25941                         _, err := w.Write(((*(*(struct {
25942                                 Type AnimType
25943
25944                                 //mt:if %s.Type == SpriteSheetAnim
25945                                 AspectRatio [2]uint8
25946
25947                                 //mt:if %s.Type == VerticalFrameAnim
25948                                 NFrames [2]uint16
25949
25950                                 //mt:if %s.Type != NoAnim
25951                                 Duration float32 // in seconds
25952
25953                         }))(obj)).AspectRatio)[:])
25954                         chk(err)
25955                 }
25956         }
25957         if (*(*(struct {
25958                 Type AnimType
25959
25960                 //mt:if %s.Type == SpriteSheetAnim
25961                 AspectRatio [2]uint8
25962
25963                 //mt:if %s.Type == VerticalFrameAnim
25964                 NFrames [2]uint16
25965
25966                 //mt:if %s.Type != NoAnim
25967                 Duration float32 // in seconds
25968
25969         }))(obj)).Type == VerticalFrameAnim {
25970                 for local313 := range (*(*(struct {
25971                         Type AnimType
25972
25973                         //mt:if %s.Type == SpriteSheetAnim
25974                         AspectRatio [2]uint8
25975
25976                         //mt:if %s.Type == VerticalFrameAnim
25977                         NFrames [2]uint16
25978
25979                         //mt:if %s.Type != NoAnim
25980                         Duration float32 // in seconds
25981
25982                 }))(obj)).NFrames {
25983                         {
25984                                 x := ((*(*(struct {
25985                                         Type AnimType
25986
25987                                         //mt:if %s.Type == SpriteSheetAnim
25988                                         AspectRatio [2]uint8
25989
25990                                         //mt:if %s.Type == VerticalFrameAnim
25991                                         NFrames [2]uint16
25992
25993                                         //mt:if %s.Type != NoAnim
25994                                         Duration float32 // in seconds
25995
25996                                 }))(obj)).NFrames)[local313]
25997                                 write16(w, uint16(x))
25998                         }
25999                 }
26000         }
26001         if (*(*(struct {
26002                 Type AnimType
26003
26004                 //mt:if %s.Type == SpriteSheetAnim
26005                 AspectRatio [2]uint8
26006
26007                 //mt:if %s.Type == VerticalFrameAnim
26008                 NFrames [2]uint16
26009
26010                 //mt:if %s.Type != NoAnim
26011                 Duration float32 // in seconds
26012
26013         }))(obj)).Type != NoAnim {
26014                 {
26015                         x := (*(*(struct {
26016                                 Type AnimType
26017
26018                                 //mt:if %s.Type == SpriteSheetAnim
26019                                 AspectRatio [2]uint8
26020
26021                                 //mt:if %s.Type == VerticalFrameAnim
26022                                 NFrames [2]uint16
26023
26024                                 //mt:if %s.Type != NoAnim
26025                                 Duration float32 // in seconds
26026
26027                         }))(obj)).Duration
26028                         write32(w, math.Float32bits(x))
26029                 }
26030         }
26031 }
26032
26033 func (obj *TileAnim) deserialize(r io.Reader) {
26034         if err := pcall(func() {
26035                 ((*(*(struct {
26036                         Type AnimType
26037
26038                         //mt:if %s.Type == SpriteSheetAnim
26039                         AspectRatio [2]uint8
26040
26041                         //mt:if %s.Type == VerticalFrameAnim
26042                         NFrames [2]uint16
26043
26044                         //mt:if %s.Type != NoAnim
26045                         Duration float32 // in seconds
26046
26047                 }))(obj)).Type).deserialize(r)
26048         }); err != nil {
26049                 if err == io.EOF {
26050                         chk(io.EOF)
26051                 }
26052                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
26053         }
26054         if !((*(*(struct {
26055                 Type AnimType
26056
26057                 //mt:if %s.Type == SpriteSheetAnim
26058                 AspectRatio [2]uint8
26059
26060                 //mt:if %s.Type == VerticalFrameAnim
26061                 NFrames [2]uint16
26062
26063                 //mt:if %s.Type != NoAnim
26064                 Duration float32 // in seconds
26065
26066         }))(obj)).Type < maxAnim) {
26067                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
26068         }
26069         if (*(*(struct {
26070                 Type AnimType
26071
26072                 //mt:if %s.Type == SpriteSheetAnim
26073                 AspectRatio [2]uint8
26074
26075                 //mt:if %s.Type == VerticalFrameAnim
26076                 NFrames [2]uint16
26077
26078                 //mt:if %s.Type != NoAnim
26079                 Duration float32 // in seconds
26080
26081         }))(obj)).Type == SpriteSheetAnim {
26082                 {
26083                         _, err := io.ReadFull(r, ((*(*(struct {
26084                                 Type AnimType
26085
26086                                 //mt:if %s.Type == SpriteSheetAnim
26087                                 AspectRatio [2]uint8
26088
26089                                 //mt:if %s.Type == VerticalFrameAnim
26090                                 NFrames [2]uint16
26091
26092                                 //mt:if %s.Type != NoAnim
26093                                 Duration float32 // in seconds
26094
26095                         }))(obj)).AspectRatio)[:])
26096                         chk(err)
26097                 }
26098         }
26099         if (*(*(struct {
26100                 Type AnimType
26101
26102                 //mt:if %s.Type == SpriteSheetAnim
26103                 AspectRatio [2]uint8
26104
26105                 //mt:if %s.Type == VerticalFrameAnim
26106                 NFrames [2]uint16
26107
26108                 //mt:if %s.Type != NoAnim
26109                 Duration float32 // in seconds
26110
26111         }))(obj)).Type == VerticalFrameAnim {
26112                 for local314 := range (*(*(struct {
26113                         Type AnimType
26114
26115                         //mt:if %s.Type == SpriteSheetAnim
26116                         AspectRatio [2]uint8
26117
26118                         //mt:if %s.Type == VerticalFrameAnim
26119                         NFrames [2]uint16
26120
26121                         //mt:if %s.Type != NoAnim
26122                         Duration float32 // in seconds
26123
26124                 }))(obj)).NFrames {
26125                         {
26126                                 p := &((*(*(struct {
26127                                         Type AnimType
26128
26129                                         //mt:if %s.Type == SpriteSheetAnim
26130                                         AspectRatio [2]uint8
26131
26132                                         //mt:if %s.Type == VerticalFrameAnim
26133                                         NFrames [2]uint16
26134
26135                                         //mt:if %s.Type != NoAnim
26136                                         Duration float32 // in seconds
26137
26138                                 }))(obj)).NFrames)[local314]
26139                                 *p = read16(r)
26140                         }
26141                 }
26142         }
26143         if (*(*(struct {
26144                 Type AnimType
26145
26146                 //mt:if %s.Type == SpriteSheetAnim
26147                 AspectRatio [2]uint8
26148
26149                 //mt:if %s.Type == VerticalFrameAnim
26150                 NFrames [2]uint16
26151
26152                 //mt:if %s.Type != NoAnim
26153                 Duration float32 // in seconds
26154
26155         }))(obj)).Type != NoAnim {
26156                 {
26157                         p := &(*(*(struct {
26158                                 Type AnimType
26159
26160                                 //mt:if %s.Type == SpriteSheetAnim
26161                                 AspectRatio [2]uint8
26162
26163                                 //mt:if %s.Type == VerticalFrameAnim
26164                                 NFrames [2]uint16
26165
26166                                 //mt:if %s.Type != NoAnim
26167                                 Duration float32 // in seconds
26168
26169                         }))(obj)).Duration
26170                         *p = math.Float32frombits(read32(r))
26171                 }
26172         }
26173 }
26174
26175 func (obj *Content) serialize(w io.Writer) {
26176         {
26177                 x := *(*(uint16))(obj)
26178                 write16(w, uint16(x))
26179         }
26180 }
26181
26182 func (obj *Content) deserialize(r io.Reader) {
26183         {
26184                 p := &*(*(uint16))(obj)
26185                 *p = read16(r)
26186         }
26187 }
26188
26189 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
26190         {
26191                 x := *(*(uint32))(obj)
26192                 write32(w, uint32(x))
26193         }
26194 }
26195
26196 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
26197         {
26198                 p := &*(*(uint32))(obj)
26199                 *p = read32(r)
26200         }
26201 }
26202
26203 func (obj *HUDID) serialize(w io.Writer) {
26204         {
26205                 x := *(*(uint32))(obj)
26206                 write32(w, uint32(x))
26207         }
26208 }
26209
26210 func (obj *HUDID) deserialize(r io.Reader) {
26211         {
26212                 p := &*(*(uint32))(obj)
26213                 *p = read32(r)
26214         }
26215 }
26216
26217 func (obj *HUD) serialize(w io.Writer) {
26218         if err := pcall(func() {
26219                 ((*(*(struct {
26220                         Type HUDType
26221
26222                         Pos      [2]float32
26223                         Name     string
26224                         Scale    [2]float32
26225                         Text     string
26226                         Number   uint32
26227                         Item     uint32
26228                         Dir      uint32
26229                         Align    [2]float32
26230                         Offset   [2]float32
26231                         WorldPos Pos
26232                         Size     [2]int32
26233                         ZIndex   int16
26234                         Text2    string
26235                         Style    uint32
26236                 }))(obj)).Type).serialize(w)
26237         }); err != nil {
26238                 if err == io.EOF {
26239                         chk(io.EOF)
26240                 }
26241                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
26242         }
26243         for local315 := range (*(*(struct {
26244                 Type HUDType
26245
26246                 Pos      [2]float32
26247                 Name     string
26248                 Scale    [2]float32
26249                 Text     string
26250                 Number   uint32
26251                 Item     uint32
26252                 Dir      uint32
26253                 Align    [2]float32
26254                 Offset   [2]float32
26255                 WorldPos Pos
26256                 Size     [2]int32
26257                 ZIndex   int16
26258                 Text2    string
26259                 Style    uint32
26260         }))(obj)).Pos {
26261                 {
26262                         x := ((*(*(struct {
26263                                 Type HUDType
26264
26265                                 Pos      [2]float32
26266                                 Name     string
26267                                 Scale    [2]float32
26268                                 Text     string
26269                                 Number   uint32
26270                                 Item     uint32
26271                                 Dir      uint32
26272                                 Align    [2]float32
26273                                 Offset   [2]float32
26274                                 WorldPos Pos
26275                                 Size     [2]int32
26276                                 ZIndex   int16
26277                                 Text2    string
26278                                 Style    uint32
26279                         }))(obj)).Pos)[local315]
26280                         write32(w, math.Float32bits(x))
26281                 }
26282         }
26283         if len(([]byte((*(*(struct {
26284                 Type HUDType
26285
26286                 Pos      [2]float32
26287                 Name     string
26288                 Scale    [2]float32
26289                 Text     string
26290                 Number   uint32
26291                 Item     uint32
26292                 Dir      uint32
26293                 Align    [2]float32
26294                 Offset   [2]float32
26295                 WorldPos Pos
26296                 Size     [2]int32
26297                 ZIndex   int16
26298                 Text2    string
26299                 Style    uint32
26300         }))(obj)).Name))) > math.MaxUint16 {
26301                 chk(ErrTooLong)
26302         }
26303         {
26304                 x := uint16(len(([]byte((*(*(struct {
26305                         Type HUDType
26306
26307                         Pos      [2]float32
26308                         Name     string
26309                         Scale    [2]float32
26310                         Text     string
26311                         Number   uint32
26312                         Item     uint32
26313                         Dir      uint32
26314                         Align    [2]float32
26315                         Offset   [2]float32
26316                         WorldPos Pos
26317                         Size     [2]int32
26318                         ZIndex   int16
26319                         Text2    string
26320                         Style    uint32
26321                 }))(obj)).Name))))
26322                 write16(w, uint16(x))
26323         }
26324         {
26325                 _, err := w.Write(([]byte((*(*(struct {
26326                         Type HUDType
26327
26328                         Pos      [2]float32
26329                         Name     string
26330                         Scale    [2]float32
26331                         Text     string
26332                         Number   uint32
26333                         Item     uint32
26334                         Dir      uint32
26335                         Align    [2]float32
26336                         Offset   [2]float32
26337                         WorldPos Pos
26338                         Size     [2]int32
26339                         ZIndex   int16
26340                         Text2    string
26341                         Style    uint32
26342                 }))(obj)).Name))[:])
26343                 chk(err)
26344         }
26345         for local316 := range (*(*(struct {
26346                 Type HUDType
26347
26348                 Pos      [2]float32
26349                 Name     string
26350                 Scale    [2]float32
26351                 Text     string
26352                 Number   uint32
26353                 Item     uint32
26354                 Dir      uint32
26355                 Align    [2]float32
26356                 Offset   [2]float32
26357                 WorldPos Pos
26358                 Size     [2]int32
26359                 ZIndex   int16
26360                 Text2    string
26361                 Style    uint32
26362         }))(obj)).Scale {
26363                 {
26364                         x := ((*(*(struct {
26365                                 Type HUDType
26366
26367                                 Pos      [2]float32
26368                                 Name     string
26369                                 Scale    [2]float32
26370                                 Text     string
26371                                 Number   uint32
26372                                 Item     uint32
26373                                 Dir      uint32
26374                                 Align    [2]float32
26375                                 Offset   [2]float32
26376                                 WorldPos Pos
26377                                 Size     [2]int32
26378                                 ZIndex   int16
26379                                 Text2    string
26380                                 Style    uint32
26381                         }))(obj)).Scale)[local316]
26382                         write32(w, math.Float32bits(x))
26383                 }
26384         }
26385         if len(([]byte((*(*(struct {
26386                 Type HUDType
26387
26388                 Pos      [2]float32
26389                 Name     string
26390                 Scale    [2]float32
26391                 Text     string
26392                 Number   uint32
26393                 Item     uint32
26394                 Dir      uint32
26395                 Align    [2]float32
26396                 Offset   [2]float32
26397                 WorldPos Pos
26398                 Size     [2]int32
26399                 ZIndex   int16
26400                 Text2    string
26401                 Style    uint32
26402         }))(obj)).Text))) > math.MaxUint16 {
26403                 chk(ErrTooLong)
26404         }
26405         {
26406                 x := uint16(len(([]byte((*(*(struct {
26407                         Type HUDType
26408
26409                         Pos      [2]float32
26410                         Name     string
26411                         Scale    [2]float32
26412                         Text     string
26413                         Number   uint32
26414                         Item     uint32
26415                         Dir      uint32
26416                         Align    [2]float32
26417                         Offset   [2]float32
26418                         WorldPos Pos
26419                         Size     [2]int32
26420                         ZIndex   int16
26421                         Text2    string
26422                         Style    uint32
26423                 }))(obj)).Text))))
26424                 write16(w, uint16(x))
26425         }
26426         {
26427                 _, err := w.Write(([]byte((*(*(struct {
26428                         Type HUDType
26429
26430                         Pos      [2]float32
26431                         Name     string
26432                         Scale    [2]float32
26433                         Text     string
26434                         Number   uint32
26435                         Item     uint32
26436                         Dir      uint32
26437                         Align    [2]float32
26438                         Offset   [2]float32
26439                         WorldPos Pos
26440                         Size     [2]int32
26441                         ZIndex   int16
26442                         Text2    string
26443                         Style    uint32
26444                 }))(obj)).Text))[:])
26445                 chk(err)
26446         }
26447         {
26448                 x := (*(*(struct {
26449                         Type HUDType
26450
26451                         Pos      [2]float32
26452                         Name     string
26453                         Scale    [2]float32
26454                         Text     string
26455                         Number   uint32
26456                         Item     uint32
26457                         Dir      uint32
26458                         Align    [2]float32
26459                         Offset   [2]float32
26460                         WorldPos Pos
26461                         Size     [2]int32
26462                         ZIndex   int16
26463                         Text2    string
26464                         Style    uint32
26465                 }))(obj)).Number
26466                 write32(w, uint32(x))
26467         }
26468         {
26469                 x := (*(*(struct {
26470                         Type HUDType
26471
26472                         Pos      [2]float32
26473                         Name     string
26474                         Scale    [2]float32
26475                         Text     string
26476                         Number   uint32
26477                         Item     uint32
26478                         Dir      uint32
26479                         Align    [2]float32
26480                         Offset   [2]float32
26481                         WorldPos Pos
26482                         Size     [2]int32
26483                         ZIndex   int16
26484                         Text2    string
26485                         Style    uint32
26486                 }))(obj)).Item
26487                 write32(w, uint32(x))
26488         }
26489         {
26490                 x := (*(*(struct {
26491                         Type HUDType
26492
26493                         Pos      [2]float32
26494                         Name     string
26495                         Scale    [2]float32
26496                         Text     string
26497                         Number   uint32
26498                         Item     uint32
26499                         Dir      uint32
26500                         Align    [2]float32
26501                         Offset   [2]float32
26502                         WorldPos Pos
26503                         Size     [2]int32
26504                         ZIndex   int16
26505                         Text2    string
26506                         Style    uint32
26507                 }))(obj)).Dir
26508                 write32(w, uint32(x))
26509         }
26510         for local317 := range (*(*(struct {
26511                 Type HUDType
26512
26513                 Pos      [2]float32
26514                 Name     string
26515                 Scale    [2]float32
26516                 Text     string
26517                 Number   uint32
26518                 Item     uint32
26519                 Dir      uint32
26520                 Align    [2]float32
26521                 Offset   [2]float32
26522                 WorldPos Pos
26523                 Size     [2]int32
26524                 ZIndex   int16
26525                 Text2    string
26526                 Style    uint32
26527         }))(obj)).Align {
26528                 {
26529                         x := ((*(*(struct {
26530                                 Type HUDType
26531
26532                                 Pos      [2]float32
26533                                 Name     string
26534                                 Scale    [2]float32
26535                                 Text     string
26536                                 Number   uint32
26537                                 Item     uint32
26538                                 Dir      uint32
26539                                 Align    [2]float32
26540                                 Offset   [2]float32
26541                                 WorldPos Pos
26542                                 Size     [2]int32
26543                                 ZIndex   int16
26544                                 Text2    string
26545                                 Style    uint32
26546                         }))(obj)).Align)[local317]
26547                         write32(w, math.Float32bits(x))
26548                 }
26549         }
26550         for local318 := range (*(*(struct {
26551                 Type HUDType
26552
26553                 Pos      [2]float32
26554                 Name     string
26555                 Scale    [2]float32
26556                 Text     string
26557                 Number   uint32
26558                 Item     uint32
26559                 Dir      uint32
26560                 Align    [2]float32
26561                 Offset   [2]float32
26562                 WorldPos Pos
26563                 Size     [2]int32
26564                 ZIndex   int16
26565                 Text2    string
26566                 Style    uint32
26567         }))(obj)).Offset {
26568                 {
26569                         x := ((*(*(struct {
26570                                 Type HUDType
26571
26572                                 Pos      [2]float32
26573                                 Name     string
26574                                 Scale    [2]float32
26575                                 Text     string
26576                                 Number   uint32
26577                                 Item     uint32
26578                                 Dir      uint32
26579                                 Align    [2]float32
26580                                 Offset   [2]float32
26581                                 WorldPos Pos
26582                                 Size     [2]int32
26583                                 ZIndex   int16
26584                                 Text2    string
26585                                 Style    uint32
26586                         }))(obj)).Offset)[local318]
26587                         write32(w, math.Float32bits(x))
26588                 }
26589         }
26590         if err := pcall(func() {
26591                 ((*(*(struct {
26592                         Type HUDType
26593
26594                         Pos      [2]float32
26595                         Name     string
26596                         Scale    [2]float32
26597                         Text     string
26598                         Number   uint32
26599                         Item     uint32
26600                         Dir      uint32
26601                         Align    [2]float32
26602                         Offset   [2]float32
26603                         WorldPos Pos
26604                         Size     [2]int32
26605                         ZIndex   int16
26606                         Text2    string
26607                         Style    uint32
26608                 }))(obj)).WorldPos).serialize(w)
26609         }); err != nil {
26610                 if err == io.EOF {
26611                         chk(io.EOF)
26612                 }
26613                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
26614         }
26615         for local319 := range (*(*(struct {
26616                 Type HUDType
26617
26618                 Pos      [2]float32
26619                 Name     string
26620                 Scale    [2]float32
26621                 Text     string
26622                 Number   uint32
26623                 Item     uint32
26624                 Dir      uint32
26625                 Align    [2]float32
26626                 Offset   [2]float32
26627                 WorldPos Pos
26628                 Size     [2]int32
26629                 ZIndex   int16
26630                 Text2    string
26631                 Style    uint32
26632         }))(obj)).Size {
26633                 {
26634                         x := ((*(*(struct {
26635                                 Type HUDType
26636
26637                                 Pos      [2]float32
26638                                 Name     string
26639                                 Scale    [2]float32
26640                                 Text     string
26641                                 Number   uint32
26642                                 Item     uint32
26643                                 Dir      uint32
26644                                 Align    [2]float32
26645                                 Offset   [2]float32
26646                                 WorldPos Pos
26647                                 Size     [2]int32
26648                                 ZIndex   int16
26649                                 Text2    string
26650                                 Style    uint32
26651                         }))(obj)).Size)[local319]
26652                         write32(w, uint32(x))
26653                 }
26654         }
26655         {
26656                 x := (*(*(struct {
26657                         Type HUDType
26658
26659                         Pos      [2]float32
26660                         Name     string
26661                         Scale    [2]float32
26662                         Text     string
26663                         Number   uint32
26664                         Item     uint32
26665                         Dir      uint32
26666                         Align    [2]float32
26667                         Offset   [2]float32
26668                         WorldPos Pos
26669                         Size     [2]int32
26670                         ZIndex   int16
26671                         Text2    string
26672                         Style    uint32
26673                 }))(obj)).ZIndex
26674                 write16(w, uint16(x))
26675         }
26676         if len(([]byte((*(*(struct {
26677                 Type HUDType
26678
26679                 Pos      [2]float32
26680                 Name     string
26681                 Scale    [2]float32
26682                 Text     string
26683                 Number   uint32
26684                 Item     uint32
26685                 Dir      uint32
26686                 Align    [2]float32
26687                 Offset   [2]float32
26688                 WorldPos Pos
26689                 Size     [2]int32
26690                 ZIndex   int16
26691                 Text2    string
26692                 Style    uint32
26693         }))(obj)).Text2))) > math.MaxUint16 {
26694                 chk(ErrTooLong)
26695         }
26696         {
26697                 x := uint16(len(([]byte((*(*(struct {
26698                         Type HUDType
26699
26700                         Pos      [2]float32
26701                         Name     string
26702                         Scale    [2]float32
26703                         Text     string
26704                         Number   uint32
26705                         Item     uint32
26706                         Dir      uint32
26707                         Align    [2]float32
26708                         Offset   [2]float32
26709                         WorldPos Pos
26710                         Size     [2]int32
26711                         ZIndex   int16
26712                         Text2    string
26713                         Style    uint32
26714                 }))(obj)).Text2))))
26715                 write16(w, uint16(x))
26716         }
26717         {
26718                 _, err := w.Write(([]byte((*(*(struct {
26719                         Type HUDType
26720
26721                         Pos      [2]float32
26722                         Name     string
26723                         Scale    [2]float32
26724                         Text     string
26725                         Number   uint32
26726                         Item     uint32
26727                         Dir      uint32
26728                         Align    [2]float32
26729                         Offset   [2]float32
26730                         WorldPos Pos
26731                         Size     [2]int32
26732                         ZIndex   int16
26733                         Text2    string
26734                         Style    uint32
26735                 }))(obj)).Text2))[:])
26736                 chk(err)
26737         }
26738         {
26739                 x := (*(*(struct {
26740                         Type HUDType
26741
26742                         Pos      [2]float32
26743                         Name     string
26744                         Scale    [2]float32
26745                         Text     string
26746                         Number   uint32
26747                         Item     uint32
26748                         Dir      uint32
26749                         Align    [2]float32
26750                         Offset   [2]float32
26751                         WorldPos Pos
26752                         Size     [2]int32
26753                         ZIndex   int16
26754                         Text2    string
26755                         Style    uint32
26756                 }))(obj)).Style
26757                 write32(w, uint32(x))
26758         }
26759 }
26760
26761 func (obj *HUD) deserialize(r io.Reader) {
26762         if err := pcall(func() {
26763                 ((*(*(struct {
26764                         Type HUDType
26765
26766                         Pos      [2]float32
26767                         Name     string
26768                         Scale    [2]float32
26769                         Text     string
26770                         Number   uint32
26771                         Item     uint32
26772                         Dir      uint32
26773                         Align    [2]float32
26774                         Offset   [2]float32
26775                         WorldPos Pos
26776                         Size     [2]int32
26777                         ZIndex   int16
26778                         Text2    string
26779                         Style    uint32
26780                 }))(obj)).Type).deserialize(r)
26781         }); err != nil {
26782                 if err == io.EOF {
26783                         chk(io.EOF)
26784                 }
26785                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
26786         }
26787         for local320 := range (*(*(struct {
26788                 Type HUDType
26789
26790                 Pos      [2]float32
26791                 Name     string
26792                 Scale    [2]float32
26793                 Text     string
26794                 Number   uint32
26795                 Item     uint32
26796                 Dir      uint32
26797                 Align    [2]float32
26798                 Offset   [2]float32
26799                 WorldPos Pos
26800                 Size     [2]int32
26801                 ZIndex   int16
26802                 Text2    string
26803                 Style    uint32
26804         }))(obj)).Pos {
26805                 {
26806                         p := &((*(*(struct {
26807                                 Type HUDType
26808
26809                                 Pos      [2]float32
26810                                 Name     string
26811                                 Scale    [2]float32
26812                                 Text     string
26813                                 Number   uint32
26814                                 Item     uint32
26815                                 Dir      uint32
26816                                 Align    [2]float32
26817                                 Offset   [2]float32
26818                                 WorldPos Pos
26819                                 Size     [2]int32
26820                                 ZIndex   int16
26821                                 Text2    string
26822                                 Style    uint32
26823                         }))(obj)).Pos)[local320]
26824                         *p = math.Float32frombits(read32(r))
26825                 }
26826         }
26827         var local321 []uint8
26828         var local322 uint16
26829         {
26830                 p := &local322
26831                 *p = read16(r)
26832         }
26833         (local321) = make([]uint8, local322)
26834         {
26835                 _, err := io.ReadFull(r, (local321)[:])
26836                 chk(err)
26837         }
26838         ((*(*(struct {
26839                 Type HUDType
26840
26841                 Pos      [2]float32
26842                 Name     string
26843                 Scale    [2]float32
26844                 Text     string
26845                 Number   uint32
26846                 Item     uint32
26847                 Dir      uint32
26848                 Align    [2]float32
26849                 Offset   [2]float32
26850                 WorldPos Pos
26851                 Size     [2]int32
26852                 ZIndex   int16
26853                 Text2    string
26854                 Style    uint32
26855         }))(obj)).Name) = string(local321)
26856         for local323 := range (*(*(struct {
26857                 Type HUDType
26858
26859                 Pos      [2]float32
26860                 Name     string
26861                 Scale    [2]float32
26862                 Text     string
26863                 Number   uint32
26864                 Item     uint32
26865                 Dir      uint32
26866                 Align    [2]float32
26867                 Offset   [2]float32
26868                 WorldPos Pos
26869                 Size     [2]int32
26870                 ZIndex   int16
26871                 Text2    string
26872                 Style    uint32
26873         }))(obj)).Scale {
26874                 {
26875                         p := &((*(*(struct {
26876                                 Type HUDType
26877
26878                                 Pos      [2]float32
26879                                 Name     string
26880                                 Scale    [2]float32
26881                                 Text     string
26882                                 Number   uint32
26883                                 Item     uint32
26884                                 Dir      uint32
26885                                 Align    [2]float32
26886                                 Offset   [2]float32
26887                                 WorldPos Pos
26888                                 Size     [2]int32
26889                                 ZIndex   int16
26890                                 Text2    string
26891                                 Style    uint32
26892                         }))(obj)).Scale)[local323]
26893                         *p = math.Float32frombits(read32(r))
26894                 }
26895         }
26896         var local324 []uint8
26897         var local325 uint16
26898         {
26899                 p := &local325
26900                 *p = read16(r)
26901         }
26902         (local324) = make([]uint8, local325)
26903         {
26904                 _, err := io.ReadFull(r, (local324)[:])
26905                 chk(err)
26906         }
26907         ((*(*(struct {
26908                 Type HUDType
26909
26910                 Pos      [2]float32
26911                 Name     string
26912                 Scale    [2]float32
26913                 Text     string
26914                 Number   uint32
26915                 Item     uint32
26916                 Dir      uint32
26917                 Align    [2]float32
26918                 Offset   [2]float32
26919                 WorldPos Pos
26920                 Size     [2]int32
26921                 ZIndex   int16
26922                 Text2    string
26923                 Style    uint32
26924         }))(obj)).Text) = string(local324)
26925         {
26926                 p := &(*(*(struct {
26927                         Type HUDType
26928
26929                         Pos      [2]float32
26930                         Name     string
26931                         Scale    [2]float32
26932                         Text     string
26933                         Number   uint32
26934                         Item     uint32
26935                         Dir      uint32
26936                         Align    [2]float32
26937                         Offset   [2]float32
26938                         WorldPos Pos
26939                         Size     [2]int32
26940                         ZIndex   int16
26941                         Text2    string
26942                         Style    uint32
26943                 }))(obj)).Number
26944                 *p = read32(r)
26945         }
26946         {
26947                 p := &(*(*(struct {
26948                         Type HUDType
26949
26950                         Pos      [2]float32
26951                         Name     string
26952                         Scale    [2]float32
26953                         Text     string
26954                         Number   uint32
26955                         Item     uint32
26956                         Dir      uint32
26957                         Align    [2]float32
26958                         Offset   [2]float32
26959                         WorldPos Pos
26960                         Size     [2]int32
26961                         ZIndex   int16
26962                         Text2    string
26963                         Style    uint32
26964                 }))(obj)).Item
26965                 *p = read32(r)
26966         }
26967         {
26968                 p := &(*(*(struct {
26969                         Type HUDType
26970
26971                         Pos      [2]float32
26972                         Name     string
26973                         Scale    [2]float32
26974                         Text     string
26975                         Number   uint32
26976                         Item     uint32
26977                         Dir      uint32
26978                         Align    [2]float32
26979                         Offset   [2]float32
26980                         WorldPos Pos
26981                         Size     [2]int32
26982                         ZIndex   int16
26983                         Text2    string
26984                         Style    uint32
26985                 }))(obj)).Dir
26986                 *p = read32(r)
26987         }
26988         for local326 := range (*(*(struct {
26989                 Type HUDType
26990
26991                 Pos      [2]float32
26992                 Name     string
26993                 Scale    [2]float32
26994                 Text     string
26995                 Number   uint32
26996                 Item     uint32
26997                 Dir      uint32
26998                 Align    [2]float32
26999                 Offset   [2]float32
27000                 WorldPos Pos
27001                 Size     [2]int32
27002                 ZIndex   int16
27003                 Text2    string
27004                 Style    uint32
27005         }))(obj)).Align {
27006                 {
27007                         p := &((*(*(struct {
27008                                 Type HUDType
27009
27010                                 Pos      [2]float32
27011                                 Name     string
27012                                 Scale    [2]float32
27013                                 Text     string
27014                                 Number   uint32
27015                                 Item     uint32
27016                                 Dir      uint32
27017                                 Align    [2]float32
27018                                 Offset   [2]float32
27019                                 WorldPos Pos
27020                                 Size     [2]int32
27021                                 ZIndex   int16
27022                                 Text2    string
27023                                 Style    uint32
27024                         }))(obj)).Align)[local326]
27025                         *p = math.Float32frombits(read32(r))
27026                 }
27027         }
27028         for local327 := range (*(*(struct {
27029                 Type HUDType
27030
27031                 Pos      [2]float32
27032                 Name     string
27033                 Scale    [2]float32
27034                 Text     string
27035                 Number   uint32
27036                 Item     uint32
27037                 Dir      uint32
27038                 Align    [2]float32
27039                 Offset   [2]float32
27040                 WorldPos Pos
27041                 Size     [2]int32
27042                 ZIndex   int16
27043                 Text2    string
27044                 Style    uint32
27045         }))(obj)).Offset {
27046                 {
27047                         p := &((*(*(struct {
27048                                 Type HUDType
27049
27050                                 Pos      [2]float32
27051                                 Name     string
27052                                 Scale    [2]float32
27053                                 Text     string
27054                                 Number   uint32
27055                                 Item     uint32
27056                                 Dir      uint32
27057                                 Align    [2]float32
27058                                 Offset   [2]float32
27059                                 WorldPos Pos
27060                                 Size     [2]int32
27061                                 ZIndex   int16
27062                                 Text2    string
27063                                 Style    uint32
27064                         }))(obj)).Offset)[local327]
27065                         *p = math.Float32frombits(read32(r))
27066                 }
27067         }
27068         if err := pcall(func() {
27069                 ((*(*(struct {
27070                         Type HUDType
27071
27072                         Pos      [2]float32
27073                         Name     string
27074                         Scale    [2]float32
27075                         Text     string
27076                         Number   uint32
27077                         Item     uint32
27078                         Dir      uint32
27079                         Align    [2]float32
27080                         Offset   [2]float32
27081                         WorldPos Pos
27082                         Size     [2]int32
27083                         ZIndex   int16
27084                         Text2    string
27085                         Style    uint32
27086                 }))(obj)).WorldPos).deserialize(r)
27087         }); err != nil {
27088                 if err == io.EOF {
27089                         chk(io.EOF)
27090                 }
27091                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
27092         }
27093         for local328 := range (*(*(struct {
27094                 Type HUDType
27095
27096                 Pos      [2]float32
27097                 Name     string
27098                 Scale    [2]float32
27099                 Text     string
27100                 Number   uint32
27101                 Item     uint32
27102                 Dir      uint32
27103                 Align    [2]float32
27104                 Offset   [2]float32
27105                 WorldPos Pos
27106                 Size     [2]int32
27107                 ZIndex   int16
27108                 Text2    string
27109                 Style    uint32
27110         }))(obj)).Size {
27111                 {
27112                         p := &((*(*(struct {
27113                                 Type HUDType
27114
27115                                 Pos      [2]float32
27116                                 Name     string
27117                                 Scale    [2]float32
27118                                 Text     string
27119                                 Number   uint32
27120                                 Item     uint32
27121                                 Dir      uint32
27122                                 Align    [2]float32
27123                                 Offset   [2]float32
27124                                 WorldPos Pos
27125                                 Size     [2]int32
27126                                 ZIndex   int16
27127                                 Text2    string
27128                                 Style    uint32
27129                         }))(obj)).Size)[local328]
27130                         *p = int32(read32(r))
27131                 }
27132         }
27133         {
27134                 p := &(*(*(struct {
27135                         Type HUDType
27136
27137                         Pos      [2]float32
27138                         Name     string
27139                         Scale    [2]float32
27140                         Text     string
27141                         Number   uint32
27142                         Item     uint32
27143                         Dir      uint32
27144                         Align    [2]float32
27145                         Offset   [2]float32
27146                         WorldPos Pos
27147                         Size     [2]int32
27148                         ZIndex   int16
27149                         Text2    string
27150                         Style    uint32
27151                 }))(obj)).ZIndex
27152                 *p = int16(read16(r))
27153         }
27154         var local329 []uint8
27155         var local330 uint16
27156         {
27157                 p := &local330
27158                 *p = read16(r)
27159         }
27160         (local329) = make([]uint8, local330)
27161         {
27162                 _, err := io.ReadFull(r, (local329)[:])
27163                 chk(err)
27164         }
27165         ((*(*(struct {
27166                 Type HUDType
27167
27168                 Pos      [2]float32
27169                 Name     string
27170                 Scale    [2]float32
27171                 Text     string
27172                 Number   uint32
27173                 Item     uint32
27174                 Dir      uint32
27175                 Align    [2]float32
27176                 Offset   [2]float32
27177                 WorldPos Pos
27178                 Size     [2]int32
27179                 ZIndex   int16
27180                 Text2    string
27181                 Style    uint32
27182         }))(obj)).Text2) = string(local329)
27183         {
27184                 p := &(*(*(struct {
27185                         Type HUDType
27186
27187                         Pos      [2]float32
27188                         Name     string
27189                         Scale    [2]float32
27190                         Text     string
27191                         Number   uint32
27192                         Item     uint32
27193                         Dir      uint32
27194                         Align    [2]float32
27195                         Offset   [2]float32
27196                         WorldPos Pos
27197                         Size     [2]int32
27198                         ZIndex   int16
27199                         Text2    string
27200                         Style    uint32
27201                 }))(obj)).Style
27202                 *p = read32(r)
27203         }
27204 }
27205
27206 func (obj *HUDField) serialize(w io.Writer) {
27207         {
27208                 x := *(*(uint8))(obj)
27209                 write8(w, uint8(x))
27210         }
27211 }
27212
27213 func (obj *HUDField) deserialize(r io.Reader) {
27214         {
27215                 p := &*(*(uint8))(obj)
27216                 *p = read8(r)
27217         }
27218 }
27219
27220 func (obj *HUDStyleFlags) serialize(w io.Writer) {
27221         {
27222                 x := *(*(uint32))(obj)
27223                 write32(w, uint32(x))
27224         }
27225 }
27226
27227 func (obj *HUDStyleFlags) deserialize(r io.Reader) {
27228         {
27229                 p := &*(*(uint32))(obj)
27230                 *p = read32(r)
27231         }
27232 }
27233
27234 func (obj *HUDFlags) serialize(w io.Writer) {
27235         {
27236                 x := *(*(uint32))(obj)
27237                 write32(w, uint32(x))
27238         }
27239 }
27240
27241 func (obj *HUDFlags) deserialize(r io.Reader) {
27242         {
27243                 p := &*(*(uint32))(obj)
27244                 *p = read32(r)
27245         }
27246 }
27247
27248 func (obj *HotbarParam) serialize(w io.Writer) {
27249         {
27250                 x := *(*(uint16))(obj)
27251                 write16(w, uint16(x))
27252         }
27253 }
27254
27255 func (obj *HotbarParam) deserialize(r io.Reader) {
27256         {
27257                 p := &*(*(uint16))(obj)
27258                 *p = read16(r)
27259         }
27260 }
27261
27262 func (obj *Texture) serialize(w io.Writer) {
27263         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
27264                 chk(ErrTooLong)
27265         }
27266         {
27267                 x := uint16(len(([]byte(*(*(string))(obj)))))
27268                 write16(w, uint16(x))
27269         }
27270         {
27271                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
27272                 chk(err)
27273         }
27274 }
27275
27276 func (obj *Texture) deserialize(r io.Reader) {
27277         var local331 []uint8
27278         var local332 uint16
27279         {
27280                 p := &local332
27281                 *p = read16(r)
27282         }
27283         (local331) = make([]uint8, local332)
27284         {
27285                 _, err := io.ReadFull(r, (local331)[:])
27286                 chk(err)
27287         }
27288         (*(*(string))(obj)) = string(local331)
27289 }
27290
27291 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
27292         {
27293                 x := *(*(uint8))(obj)
27294                 write8(w, uint8(x))
27295         }
27296 }
27297
27298 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
27299         {
27300                 p := &*(*(uint8))(obj)
27301                 *p = read8(r)
27302         }
27303 }
27304
27305 func (obj *ModChanSig) serialize(w io.Writer) {
27306         {
27307                 x := *(*(uint8))(obj)
27308                 write8(w, uint8(x))
27309         }
27310 }
27311
27312 func (obj *ModChanSig) deserialize(r io.Reader) {
27313         {
27314                 p := &*(*(uint8))(obj)
27315                 *p = read8(r)
27316         }
27317 }
27318
27319 func (obj *AOProps) serialize(w io.Writer) {
27320         {
27321                 local333 := uint8(4)
27322                 {
27323                         x := local333
27324                         write8(w, uint8(x))
27325                 }
27326         }
27327         {
27328                 x := (*(*(struct {
27329                         MaxHP            uint16 // Player only.
27330                         CollideWithNodes bool
27331                         Weight           float32 // deprecated
27332                         ColBox, SelBox   Box
27333                         Pointable        bool
27334                         Visual           string
27335                         VisualSize       [3]float32
27336                         Textures         []Texture
27337                         SpriteSheetSize  [2]int16 // in sprites.
27338                         SpritePos        [2]int16 // in sprite sheet.
27339                         Visible          bool
27340                         MakeFootstepSnds bool
27341                         RotateSpeed      float32 // in radians per second.
27342                         Mesh             string
27343                         Colors           []color.NRGBA
27344                         CollideWithAOs   bool
27345                         StepHeight       float32
27346                         FaceRotateDir    bool
27347                         FaceRotateDirOff float32 // in degrees.
27348                         BackfaceCull     bool
27349                         Nametag          string
27350                         NametagColor     color.NRGBA
27351                         FaceRotateSpeed  float32 // in degrees per second.
27352                         Infotext         string
27353                         Itemstring       string
27354                         Glow             int8
27355                         MaxBreath        uint16  // Player only.
27356                         EyeHeight        float32 // Player only.
27357                         ZoomFOV          float32 // in degrees. Player only.
27358                         UseTextureAlpha  bool
27359                         DmgTextureMod    Texture // suffix
27360                         Shaded           bool
27361                         ShowOnMinimap    bool
27362                         NametagBG        color.NRGBA
27363                 }))(obj)).MaxHP
27364                 write16(w, uint16(x))
27365         }
27366         {
27367                 x := (*(*(struct {
27368                         MaxHP            uint16 // Player only.
27369                         CollideWithNodes bool
27370                         Weight           float32 // deprecated
27371                         ColBox, SelBox   Box
27372                         Pointable        bool
27373                         Visual           string
27374                         VisualSize       [3]float32
27375                         Textures         []Texture
27376                         SpriteSheetSize  [2]int16 // in sprites.
27377                         SpritePos        [2]int16 // in sprite sheet.
27378                         Visible          bool
27379                         MakeFootstepSnds bool
27380                         RotateSpeed      float32 // in radians per second.
27381                         Mesh             string
27382                         Colors           []color.NRGBA
27383                         CollideWithAOs   bool
27384                         StepHeight       float32
27385                         FaceRotateDir    bool
27386                         FaceRotateDirOff float32 // in degrees.
27387                         BackfaceCull     bool
27388                         Nametag          string
27389                         NametagColor     color.NRGBA
27390                         FaceRotateSpeed  float32 // in degrees per second.
27391                         Infotext         string
27392                         Itemstring       string
27393                         Glow             int8
27394                         MaxBreath        uint16  // Player only.
27395                         EyeHeight        float32 // Player only.
27396                         ZoomFOV          float32 // in degrees. Player only.
27397                         UseTextureAlpha  bool
27398                         DmgTextureMod    Texture // suffix
27399                         Shaded           bool
27400                         ShowOnMinimap    bool
27401                         NametagBG        color.NRGBA
27402                 }))(obj)).CollideWithNodes
27403                 if x {
27404                         write8(w, 1)
27405                 } else {
27406                         write8(w, 0)
27407                 }
27408         }
27409         {
27410                 x := (*(*(struct {
27411                         MaxHP            uint16 // Player only.
27412                         CollideWithNodes bool
27413                         Weight           float32 // deprecated
27414                         ColBox, SelBox   Box
27415                         Pointable        bool
27416                         Visual           string
27417                         VisualSize       [3]float32
27418                         Textures         []Texture
27419                         SpriteSheetSize  [2]int16 // in sprites.
27420                         SpritePos        [2]int16 // in sprite sheet.
27421                         Visible          bool
27422                         MakeFootstepSnds bool
27423                         RotateSpeed      float32 // in radians per second.
27424                         Mesh             string
27425                         Colors           []color.NRGBA
27426                         CollideWithAOs   bool
27427                         StepHeight       float32
27428                         FaceRotateDir    bool
27429                         FaceRotateDirOff float32 // in degrees.
27430                         BackfaceCull     bool
27431                         Nametag          string
27432                         NametagColor     color.NRGBA
27433                         FaceRotateSpeed  float32 // in degrees per second.
27434                         Infotext         string
27435                         Itemstring       string
27436                         Glow             int8
27437                         MaxBreath        uint16  // Player only.
27438                         EyeHeight        float32 // Player only.
27439                         ZoomFOV          float32 // in degrees. Player only.
27440                         UseTextureAlpha  bool
27441                         DmgTextureMod    Texture // suffix
27442                         Shaded           bool
27443                         ShowOnMinimap    bool
27444                         NametagBG        color.NRGBA
27445                 }))(obj)).Weight
27446                 write32(w, math.Float32bits(x))
27447         }
27448         if err := pcall(func() {
27449                 ((*(*(struct {
27450                         MaxHP            uint16 // Player only.
27451                         CollideWithNodes bool
27452                         Weight           float32 // deprecated
27453                         ColBox, SelBox   Box
27454                         Pointable        bool
27455                         Visual           string
27456                         VisualSize       [3]float32
27457                         Textures         []Texture
27458                         SpriteSheetSize  [2]int16 // in sprites.
27459                         SpritePos        [2]int16 // in sprite sheet.
27460                         Visible          bool
27461                         MakeFootstepSnds bool
27462                         RotateSpeed      float32 // in radians per second.
27463                         Mesh             string
27464                         Colors           []color.NRGBA
27465                         CollideWithAOs   bool
27466                         StepHeight       float32
27467                         FaceRotateDir    bool
27468                         FaceRotateDirOff float32 // in degrees.
27469                         BackfaceCull     bool
27470                         Nametag          string
27471                         NametagColor     color.NRGBA
27472                         FaceRotateSpeed  float32 // in degrees per second.
27473                         Infotext         string
27474                         Itemstring       string
27475                         Glow             int8
27476                         MaxBreath        uint16  // Player only.
27477                         EyeHeight        float32 // Player only.
27478                         ZoomFOV          float32 // in degrees. Player only.
27479                         UseTextureAlpha  bool
27480                         DmgTextureMod    Texture // suffix
27481                         Shaded           bool
27482                         ShowOnMinimap    bool
27483                         NametagBG        color.NRGBA
27484                 }))(obj)).ColBox).serialize(w)
27485         }); err != nil {
27486                 if err == io.EOF {
27487                         chk(io.EOF)
27488                 }
27489                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
27490         }
27491         if err := pcall(func() {
27492                 ((*(*(struct {
27493                         MaxHP            uint16 // Player only.
27494                         CollideWithNodes bool
27495                         Weight           float32 // deprecated
27496                         ColBox, SelBox   Box
27497                         Pointable        bool
27498                         Visual           string
27499                         VisualSize       [3]float32
27500                         Textures         []Texture
27501                         SpriteSheetSize  [2]int16 // in sprites.
27502                         SpritePos        [2]int16 // in sprite sheet.
27503                         Visible          bool
27504                         MakeFootstepSnds bool
27505                         RotateSpeed      float32 // in radians per second.
27506                         Mesh             string
27507                         Colors           []color.NRGBA
27508                         CollideWithAOs   bool
27509                         StepHeight       float32
27510                         FaceRotateDir    bool
27511                         FaceRotateDirOff float32 // in degrees.
27512                         BackfaceCull     bool
27513                         Nametag          string
27514                         NametagColor     color.NRGBA
27515                         FaceRotateSpeed  float32 // in degrees per second.
27516                         Infotext         string
27517                         Itemstring       string
27518                         Glow             int8
27519                         MaxBreath        uint16  // Player only.
27520                         EyeHeight        float32 // Player only.
27521                         ZoomFOV          float32 // in degrees. Player only.
27522                         UseTextureAlpha  bool
27523                         DmgTextureMod    Texture // suffix
27524                         Shaded           bool
27525                         ShowOnMinimap    bool
27526                         NametagBG        color.NRGBA
27527                 }))(obj)).SelBox).serialize(w)
27528         }); err != nil {
27529                 if err == io.EOF {
27530                         chk(io.EOF)
27531                 }
27532                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
27533         }
27534         {
27535                 x := (*(*(struct {
27536                         MaxHP            uint16 // Player only.
27537                         CollideWithNodes bool
27538                         Weight           float32 // deprecated
27539                         ColBox, SelBox   Box
27540                         Pointable        bool
27541                         Visual           string
27542                         VisualSize       [3]float32
27543                         Textures         []Texture
27544                         SpriteSheetSize  [2]int16 // in sprites.
27545                         SpritePos        [2]int16 // in sprite sheet.
27546                         Visible          bool
27547                         MakeFootstepSnds bool
27548                         RotateSpeed      float32 // in radians per second.
27549                         Mesh             string
27550                         Colors           []color.NRGBA
27551                         CollideWithAOs   bool
27552                         StepHeight       float32
27553                         FaceRotateDir    bool
27554                         FaceRotateDirOff float32 // in degrees.
27555                         BackfaceCull     bool
27556                         Nametag          string
27557                         NametagColor     color.NRGBA
27558                         FaceRotateSpeed  float32 // in degrees per second.
27559                         Infotext         string
27560                         Itemstring       string
27561                         Glow             int8
27562                         MaxBreath        uint16  // Player only.
27563                         EyeHeight        float32 // Player only.
27564                         ZoomFOV          float32 // in degrees. Player only.
27565                         UseTextureAlpha  bool
27566                         DmgTextureMod    Texture // suffix
27567                         Shaded           bool
27568                         ShowOnMinimap    bool
27569                         NametagBG        color.NRGBA
27570                 }))(obj)).Pointable
27571                 if x {
27572                         write8(w, 1)
27573                 } else {
27574                         write8(w, 0)
27575                 }
27576         }
27577         if len(([]byte((*(*(struct {
27578                 MaxHP            uint16 // Player only.
27579                 CollideWithNodes bool
27580                 Weight           float32 // deprecated
27581                 ColBox, SelBox   Box
27582                 Pointable        bool
27583                 Visual           string
27584                 VisualSize       [3]float32
27585                 Textures         []Texture
27586                 SpriteSheetSize  [2]int16 // in sprites.
27587                 SpritePos        [2]int16 // in sprite sheet.
27588                 Visible          bool
27589                 MakeFootstepSnds bool
27590                 RotateSpeed      float32 // in radians per second.
27591                 Mesh             string
27592                 Colors           []color.NRGBA
27593                 CollideWithAOs   bool
27594                 StepHeight       float32
27595                 FaceRotateDir    bool
27596                 FaceRotateDirOff float32 // in degrees.
27597                 BackfaceCull     bool
27598                 Nametag          string
27599                 NametagColor     color.NRGBA
27600                 FaceRotateSpeed  float32 // in degrees per second.
27601                 Infotext         string
27602                 Itemstring       string
27603                 Glow             int8
27604                 MaxBreath        uint16  // Player only.
27605                 EyeHeight        float32 // Player only.
27606                 ZoomFOV          float32 // in degrees. Player only.
27607                 UseTextureAlpha  bool
27608                 DmgTextureMod    Texture // suffix
27609                 Shaded           bool
27610                 ShowOnMinimap    bool
27611                 NametagBG        color.NRGBA
27612         }))(obj)).Visual))) > math.MaxUint16 {
27613                 chk(ErrTooLong)
27614         }
27615         {
27616                 x := uint16(len(([]byte((*(*(struct {
27617                         MaxHP            uint16 // Player only.
27618                         CollideWithNodes bool
27619                         Weight           float32 // deprecated
27620                         ColBox, SelBox   Box
27621                         Pointable        bool
27622                         Visual           string
27623                         VisualSize       [3]float32
27624                         Textures         []Texture
27625                         SpriteSheetSize  [2]int16 // in sprites.
27626                         SpritePos        [2]int16 // in sprite sheet.
27627                         Visible          bool
27628                         MakeFootstepSnds bool
27629                         RotateSpeed      float32 // in radians per second.
27630                         Mesh             string
27631                         Colors           []color.NRGBA
27632                         CollideWithAOs   bool
27633                         StepHeight       float32
27634                         FaceRotateDir    bool
27635                         FaceRotateDirOff float32 // in degrees.
27636                         BackfaceCull     bool
27637                         Nametag          string
27638                         NametagColor     color.NRGBA
27639                         FaceRotateSpeed  float32 // in degrees per second.
27640                         Infotext         string
27641                         Itemstring       string
27642                         Glow             int8
27643                         MaxBreath        uint16  // Player only.
27644                         EyeHeight        float32 // Player only.
27645                         ZoomFOV          float32 // in degrees. Player only.
27646                         UseTextureAlpha  bool
27647                         DmgTextureMod    Texture // suffix
27648                         Shaded           bool
27649                         ShowOnMinimap    bool
27650                         NametagBG        color.NRGBA
27651                 }))(obj)).Visual))))
27652                 write16(w, uint16(x))
27653         }
27654         {
27655                 _, err := w.Write(([]byte((*(*(struct {
27656                         MaxHP            uint16 // Player only.
27657                         CollideWithNodes bool
27658                         Weight           float32 // deprecated
27659                         ColBox, SelBox   Box
27660                         Pointable        bool
27661                         Visual           string
27662                         VisualSize       [3]float32
27663                         Textures         []Texture
27664                         SpriteSheetSize  [2]int16 // in sprites.
27665                         SpritePos        [2]int16 // in sprite sheet.
27666                         Visible          bool
27667                         MakeFootstepSnds bool
27668                         RotateSpeed      float32 // in radians per second.
27669                         Mesh             string
27670                         Colors           []color.NRGBA
27671                         CollideWithAOs   bool
27672                         StepHeight       float32
27673                         FaceRotateDir    bool
27674                         FaceRotateDirOff float32 // in degrees.
27675                         BackfaceCull     bool
27676                         Nametag          string
27677                         NametagColor     color.NRGBA
27678                         FaceRotateSpeed  float32 // in degrees per second.
27679                         Infotext         string
27680                         Itemstring       string
27681                         Glow             int8
27682                         MaxBreath        uint16  // Player only.
27683                         EyeHeight        float32 // Player only.
27684                         ZoomFOV          float32 // in degrees. Player only.
27685                         UseTextureAlpha  bool
27686                         DmgTextureMod    Texture // suffix
27687                         Shaded           bool
27688                         ShowOnMinimap    bool
27689                         NametagBG        color.NRGBA
27690                 }))(obj)).Visual))[:])
27691                 chk(err)
27692         }
27693         for local334 := range (*(*(struct {
27694                 MaxHP            uint16 // Player only.
27695                 CollideWithNodes bool
27696                 Weight           float32 // deprecated
27697                 ColBox, SelBox   Box
27698                 Pointable        bool
27699                 Visual           string
27700                 VisualSize       [3]float32
27701                 Textures         []Texture
27702                 SpriteSheetSize  [2]int16 // in sprites.
27703                 SpritePos        [2]int16 // in sprite sheet.
27704                 Visible          bool
27705                 MakeFootstepSnds bool
27706                 RotateSpeed      float32 // in radians per second.
27707                 Mesh             string
27708                 Colors           []color.NRGBA
27709                 CollideWithAOs   bool
27710                 StepHeight       float32
27711                 FaceRotateDir    bool
27712                 FaceRotateDirOff float32 // in degrees.
27713                 BackfaceCull     bool
27714                 Nametag          string
27715                 NametagColor     color.NRGBA
27716                 FaceRotateSpeed  float32 // in degrees per second.
27717                 Infotext         string
27718                 Itemstring       string
27719                 Glow             int8
27720                 MaxBreath        uint16  // Player only.
27721                 EyeHeight        float32 // Player only.
27722                 ZoomFOV          float32 // in degrees. Player only.
27723                 UseTextureAlpha  bool
27724                 DmgTextureMod    Texture // suffix
27725                 Shaded           bool
27726                 ShowOnMinimap    bool
27727                 NametagBG        color.NRGBA
27728         }))(obj)).VisualSize {
27729                 {
27730                         x := ((*(*(struct {
27731                                 MaxHP            uint16 // Player only.
27732                                 CollideWithNodes bool
27733                                 Weight           float32 // deprecated
27734                                 ColBox, SelBox   Box
27735                                 Pointable        bool
27736                                 Visual           string
27737                                 VisualSize       [3]float32
27738                                 Textures         []Texture
27739                                 SpriteSheetSize  [2]int16 // in sprites.
27740                                 SpritePos        [2]int16 // in sprite sheet.
27741                                 Visible          bool
27742                                 MakeFootstepSnds bool
27743                                 RotateSpeed      float32 // in radians per second.
27744                                 Mesh             string
27745                                 Colors           []color.NRGBA
27746                                 CollideWithAOs   bool
27747                                 StepHeight       float32
27748                                 FaceRotateDir    bool
27749                                 FaceRotateDirOff float32 // in degrees.
27750                                 BackfaceCull     bool
27751                                 Nametag          string
27752                                 NametagColor     color.NRGBA
27753                                 FaceRotateSpeed  float32 // in degrees per second.
27754                                 Infotext         string
27755                                 Itemstring       string
27756                                 Glow             int8
27757                                 MaxBreath        uint16  // Player only.
27758                                 EyeHeight        float32 // Player only.
27759                                 ZoomFOV          float32 // in degrees. Player only.
27760                                 UseTextureAlpha  bool
27761                                 DmgTextureMod    Texture // suffix
27762                                 Shaded           bool
27763                                 ShowOnMinimap    bool
27764                                 NametagBG        color.NRGBA
27765                         }))(obj)).VisualSize)[local334]
27766                         write32(w, math.Float32bits(x))
27767                 }
27768         }
27769         if len(((*(*(struct {
27770                 MaxHP            uint16 // Player only.
27771                 CollideWithNodes bool
27772                 Weight           float32 // deprecated
27773                 ColBox, SelBox   Box
27774                 Pointable        bool
27775                 Visual           string
27776                 VisualSize       [3]float32
27777                 Textures         []Texture
27778                 SpriteSheetSize  [2]int16 // in sprites.
27779                 SpritePos        [2]int16 // in sprite sheet.
27780                 Visible          bool
27781                 MakeFootstepSnds bool
27782                 RotateSpeed      float32 // in radians per second.
27783                 Mesh             string
27784                 Colors           []color.NRGBA
27785                 CollideWithAOs   bool
27786                 StepHeight       float32
27787                 FaceRotateDir    bool
27788                 FaceRotateDirOff float32 // in degrees.
27789                 BackfaceCull     bool
27790                 Nametag          string
27791                 NametagColor     color.NRGBA
27792                 FaceRotateSpeed  float32 // in degrees per second.
27793                 Infotext         string
27794                 Itemstring       string
27795                 Glow             int8
27796                 MaxBreath        uint16  // Player only.
27797                 EyeHeight        float32 // Player only.
27798                 ZoomFOV          float32 // in degrees. Player only.
27799                 UseTextureAlpha  bool
27800                 DmgTextureMod    Texture // suffix
27801                 Shaded           bool
27802                 ShowOnMinimap    bool
27803                 NametagBG        color.NRGBA
27804         }))(obj)).Textures)) > math.MaxUint16 {
27805                 chk(ErrTooLong)
27806         }
27807         {
27808                 x := uint16(len(((*(*(struct {
27809                         MaxHP            uint16 // Player only.
27810                         CollideWithNodes bool
27811                         Weight           float32 // deprecated
27812                         ColBox, SelBox   Box
27813                         Pointable        bool
27814                         Visual           string
27815                         VisualSize       [3]float32
27816                         Textures         []Texture
27817                         SpriteSheetSize  [2]int16 // in sprites.
27818                         SpritePos        [2]int16 // in sprite sheet.
27819                         Visible          bool
27820                         MakeFootstepSnds bool
27821                         RotateSpeed      float32 // in radians per second.
27822                         Mesh             string
27823                         Colors           []color.NRGBA
27824                         CollideWithAOs   bool
27825                         StepHeight       float32
27826                         FaceRotateDir    bool
27827                         FaceRotateDirOff float32 // in degrees.
27828                         BackfaceCull     bool
27829                         Nametag          string
27830                         NametagColor     color.NRGBA
27831                         FaceRotateSpeed  float32 // in degrees per second.
27832                         Infotext         string
27833                         Itemstring       string
27834                         Glow             int8
27835                         MaxBreath        uint16  // Player only.
27836                         EyeHeight        float32 // Player only.
27837                         ZoomFOV          float32 // in degrees. Player only.
27838                         UseTextureAlpha  bool
27839                         DmgTextureMod    Texture // suffix
27840                         Shaded           bool
27841                         ShowOnMinimap    bool
27842                         NametagBG        color.NRGBA
27843                 }))(obj)).Textures)))
27844                 write16(w, uint16(x))
27845         }
27846         for local335 := range (*(*(struct {
27847                 MaxHP            uint16 // Player only.
27848                 CollideWithNodes bool
27849                 Weight           float32 // deprecated
27850                 ColBox, SelBox   Box
27851                 Pointable        bool
27852                 Visual           string
27853                 VisualSize       [3]float32
27854                 Textures         []Texture
27855                 SpriteSheetSize  [2]int16 // in sprites.
27856                 SpritePos        [2]int16 // in sprite sheet.
27857                 Visible          bool
27858                 MakeFootstepSnds bool
27859                 RotateSpeed      float32 // in radians per second.
27860                 Mesh             string
27861                 Colors           []color.NRGBA
27862                 CollideWithAOs   bool
27863                 StepHeight       float32
27864                 FaceRotateDir    bool
27865                 FaceRotateDirOff float32 // in degrees.
27866                 BackfaceCull     bool
27867                 Nametag          string
27868                 NametagColor     color.NRGBA
27869                 FaceRotateSpeed  float32 // in degrees per second.
27870                 Infotext         string
27871                 Itemstring       string
27872                 Glow             int8
27873                 MaxBreath        uint16  // Player only.
27874                 EyeHeight        float32 // Player only.
27875                 ZoomFOV          float32 // in degrees. Player only.
27876                 UseTextureAlpha  bool
27877                 DmgTextureMod    Texture // suffix
27878                 Shaded           bool
27879                 ShowOnMinimap    bool
27880                 NametagBG        color.NRGBA
27881         }))(obj)).Textures {
27882                 if err := pcall(func() {
27883                         (((*(*(struct {
27884                                 MaxHP            uint16 // Player only.
27885                                 CollideWithNodes bool
27886                                 Weight           float32 // deprecated
27887                                 ColBox, SelBox   Box
27888                                 Pointable        bool
27889                                 Visual           string
27890                                 VisualSize       [3]float32
27891                                 Textures         []Texture
27892                                 SpriteSheetSize  [2]int16 // in sprites.
27893                                 SpritePos        [2]int16 // in sprite sheet.
27894                                 Visible          bool
27895                                 MakeFootstepSnds bool
27896                                 RotateSpeed      float32 // in radians per second.
27897                                 Mesh             string
27898                                 Colors           []color.NRGBA
27899                                 CollideWithAOs   bool
27900                                 StepHeight       float32
27901                                 FaceRotateDir    bool
27902                                 FaceRotateDirOff float32 // in degrees.
27903                                 BackfaceCull     bool
27904                                 Nametag          string
27905                                 NametagColor     color.NRGBA
27906                                 FaceRotateSpeed  float32 // in degrees per second.
27907                                 Infotext         string
27908                                 Itemstring       string
27909                                 Glow             int8
27910                                 MaxBreath        uint16  // Player only.
27911                                 EyeHeight        float32 // Player only.
27912                                 ZoomFOV          float32 // in degrees. Player only.
27913                                 UseTextureAlpha  bool
27914                                 DmgTextureMod    Texture // suffix
27915                                 Shaded           bool
27916                                 ShowOnMinimap    bool
27917                                 NametagBG        color.NRGBA
27918                         }))(obj)).Textures)[local335]).serialize(w)
27919                 }); err != nil {
27920                         if err == io.EOF {
27921                                 chk(io.EOF)
27922                         }
27923                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
27924                 }
27925         }
27926         for local336 := range (*(*(struct {
27927                 MaxHP            uint16 // Player only.
27928                 CollideWithNodes bool
27929                 Weight           float32 // deprecated
27930                 ColBox, SelBox   Box
27931                 Pointable        bool
27932                 Visual           string
27933                 VisualSize       [3]float32
27934                 Textures         []Texture
27935                 SpriteSheetSize  [2]int16 // in sprites.
27936                 SpritePos        [2]int16 // in sprite sheet.
27937                 Visible          bool
27938                 MakeFootstepSnds bool
27939                 RotateSpeed      float32 // in radians per second.
27940                 Mesh             string
27941                 Colors           []color.NRGBA
27942                 CollideWithAOs   bool
27943                 StepHeight       float32
27944                 FaceRotateDir    bool
27945                 FaceRotateDirOff float32 // in degrees.
27946                 BackfaceCull     bool
27947                 Nametag          string
27948                 NametagColor     color.NRGBA
27949                 FaceRotateSpeed  float32 // in degrees per second.
27950                 Infotext         string
27951                 Itemstring       string
27952                 Glow             int8
27953                 MaxBreath        uint16  // Player only.
27954                 EyeHeight        float32 // Player only.
27955                 ZoomFOV          float32 // in degrees. Player only.
27956                 UseTextureAlpha  bool
27957                 DmgTextureMod    Texture // suffix
27958                 Shaded           bool
27959                 ShowOnMinimap    bool
27960                 NametagBG        color.NRGBA
27961         }))(obj)).SpriteSheetSize {
27962                 {
27963                         x := ((*(*(struct {
27964                                 MaxHP            uint16 // Player only.
27965                                 CollideWithNodes bool
27966                                 Weight           float32 // deprecated
27967                                 ColBox, SelBox   Box
27968                                 Pointable        bool
27969                                 Visual           string
27970                                 VisualSize       [3]float32
27971                                 Textures         []Texture
27972                                 SpriteSheetSize  [2]int16 // in sprites.
27973                                 SpritePos        [2]int16 // in sprite sheet.
27974                                 Visible          bool
27975                                 MakeFootstepSnds bool
27976                                 RotateSpeed      float32 // in radians per second.
27977                                 Mesh             string
27978                                 Colors           []color.NRGBA
27979                                 CollideWithAOs   bool
27980                                 StepHeight       float32
27981                                 FaceRotateDir    bool
27982                                 FaceRotateDirOff float32 // in degrees.
27983                                 BackfaceCull     bool
27984                                 Nametag          string
27985                                 NametagColor     color.NRGBA
27986                                 FaceRotateSpeed  float32 // in degrees per second.
27987                                 Infotext         string
27988                                 Itemstring       string
27989                                 Glow             int8
27990                                 MaxBreath        uint16  // Player only.
27991                                 EyeHeight        float32 // Player only.
27992                                 ZoomFOV          float32 // in degrees. Player only.
27993                                 UseTextureAlpha  bool
27994                                 DmgTextureMod    Texture // suffix
27995                                 Shaded           bool
27996                                 ShowOnMinimap    bool
27997                                 NametagBG        color.NRGBA
27998                         }))(obj)).SpriteSheetSize)[local336]
27999                         write16(w, uint16(x))
28000                 }
28001         }
28002         for local337 := range (*(*(struct {
28003                 MaxHP            uint16 // Player only.
28004                 CollideWithNodes bool
28005                 Weight           float32 // deprecated
28006                 ColBox, SelBox   Box
28007                 Pointable        bool
28008                 Visual           string
28009                 VisualSize       [3]float32
28010                 Textures         []Texture
28011                 SpriteSheetSize  [2]int16 // in sprites.
28012                 SpritePos        [2]int16 // in sprite sheet.
28013                 Visible          bool
28014                 MakeFootstepSnds bool
28015                 RotateSpeed      float32 // in radians per second.
28016                 Mesh             string
28017                 Colors           []color.NRGBA
28018                 CollideWithAOs   bool
28019                 StepHeight       float32
28020                 FaceRotateDir    bool
28021                 FaceRotateDirOff float32 // in degrees.
28022                 BackfaceCull     bool
28023                 Nametag          string
28024                 NametagColor     color.NRGBA
28025                 FaceRotateSpeed  float32 // in degrees per second.
28026                 Infotext         string
28027                 Itemstring       string
28028                 Glow             int8
28029                 MaxBreath        uint16  // Player only.
28030                 EyeHeight        float32 // Player only.
28031                 ZoomFOV          float32 // in degrees. Player only.
28032                 UseTextureAlpha  bool
28033                 DmgTextureMod    Texture // suffix
28034                 Shaded           bool
28035                 ShowOnMinimap    bool
28036                 NametagBG        color.NRGBA
28037         }))(obj)).SpritePos {
28038                 {
28039                         x := ((*(*(struct {
28040                                 MaxHP            uint16 // Player only.
28041                                 CollideWithNodes bool
28042                                 Weight           float32 // deprecated
28043                                 ColBox, SelBox   Box
28044                                 Pointable        bool
28045                                 Visual           string
28046                                 VisualSize       [3]float32
28047                                 Textures         []Texture
28048                                 SpriteSheetSize  [2]int16 // in sprites.
28049                                 SpritePos        [2]int16 // in sprite sheet.
28050                                 Visible          bool
28051                                 MakeFootstepSnds bool
28052                                 RotateSpeed      float32 // in radians per second.
28053                                 Mesh             string
28054                                 Colors           []color.NRGBA
28055                                 CollideWithAOs   bool
28056                                 StepHeight       float32
28057                                 FaceRotateDir    bool
28058                                 FaceRotateDirOff float32 // in degrees.
28059                                 BackfaceCull     bool
28060                                 Nametag          string
28061                                 NametagColor     color.NRGBA
28062                                 FaceRotateSpeed  float32 // in degrees per second.
28063                                 Infotext         string
28064                                 Itemstring       string
28065                                 Glow             int8
28066                                 MaxBreath        uint16  // Player only.
28067                                 EyeHeight        float32 // Player only.
28068                                 ZoomFOV          float32 // in degrees. Player only.
28069                                 UseTextureAlpha  bool
28070                                 DmgTextureMod    Texture // suffix
28071                                 Shaded           bool
28072                                 ShowOnMinimap    bool
28073                                 NametagBG        color.NRGBA
28074                         }))(obj)).SpritePos)[local337]
28075                         write16(w, uint16(x))
28076                 }
28077         }
28078         {
28079                 x := (*(*(struct {
28080                         MaxHP            uint16 // Player only.
28081                         CollideWithNodes bool
28082                         Weight           float32 // deprecated
28083                         ColBox, SelBox   Box
28084                         Pointable        bool
28085                         Visual           string
28086                         VisualSize       [3]float32
28087                         Textures         []Texture
28088                         SpriteSheetSize  [2]int16 // in sprites.
28089                         SpritePos        [2]int16 // in sprite sheet.
28090                         Visible          bool
28091                         MakeFootstepSnds bool
28092                         RotateSpeed      float32 // in radians per second.
28093                         Mesh             string
28094                         Colors           []color.NRGBA
28095                         CollideWithAOs   bool
28096                         StepHeight       float32
28097                         FaceRotateDir    bool
28098                         FaceRotateDirOff float32 // in degrees.
28099                         BackfaceCull     bool
28100                         Nametag          string
28101                         NametagColor     color.NRGBA
28102                         FaceRotateSpeed  float32 // in degrees per second.
28103                         Infotext         string
28104                         Itemstring       string
28105                         Glow             int8
28106                         MaxBreath        uint16  // Player only.
28107                         EyeHeight        float32 // Player only.
28108                         ZoomFOV          float32 // in degrees. Player only.
28109                         UseTextureAlpha  bool
28110                         DmgTextureMod    Texture // suffix
28111                         Shaded           bool
28112                         ShowOnMinimap    bool
28113                         NametagBG        color.NRGBA
28114                 }))(obj)).Visible
28115                 if x {
28116                         write8(w, 1)
28117                 } else {
28118                         write8(w, 0)
28119                 }
28120         }
28121         {
28122                 x := (*(*(struct {
28123                         MaxHP            uint16 // Player only.
28124                         CollideWithNodes bool
28125                         Weight           float32 // deprecated
28126                         ColBox, SelBox   Box
28127                         Pointable        bool
28128                         Visual           string
28129                         VisualSize       [3]float32
28130                         Textures         []Texture
28131                         SpriteSheetSize  [2]int16 // in sprites.
28132                         SpritePos        [2]int16 // in sprite sheet.
28133                         Visible          bool
28134                         MakeFootstepSnds bool
28135                         RotateSpeed      float32 // in radians per second.
28136                         Mesh             string
28137                         Colors           []color.NRGBA
28138                         CollideWithAOs   bool
28139                         StepHeight       float32
28140                         FaceRotateDir    bool
28141                         FaceRotateDirOff float32 // in degrees.
28142                         BackfaceCull     bool
28143                         Nametag          string
28144                         NametagColor     color.NRGBA
28145                         FaceRotateSpeed  float32 // in degrees per second.
28146                         Infotext         string
28147                         Itemstring       string
28148                         Glow             int8
28149                         MaxBreath        uint16  // Player only.
28150                         EyeHeight        float32 // Player only.
28151                         ZoomFOV          float32 // in degrees. Player only.
28152                         UseTextureAlpha  bool
28153                         DmgTextureMod    Texture // suffix
28154                         Shaded           bool
28155                         ShowOnMinimap    bool
28156                         NametagBG        color.NRGBA
28157                 }))(obj)).MakeFootstepSnds
28158                 if x {
28159                         write8(w, 1)
28160                 } else {
28161                         write8(w, 0)
28162                 }
28163         }
28164         {
28165                 x := (*(*(struct {
28166                         MaxHP            uint16 // Player only.
28167                         CollideWithNodes bool
28168                         Weight           float32 // deprecated
28169                         ColBox, SelBox   Box
28170                         Pointable        bool
28171                         Visual           string
28172                         VisualSize       [3]float32
28173                         Textures         []Texture
28174                         SpriteSheetSize  [2]int16 // in sprites.
28175                         SpritePos        [2]int16 // in sprite sheet.
28176                         Visible          bool
28177                         MakeFootstepSnds bool
28178                         RotateSpeed      float32 // in radians per second.
28179                         Mesh             string
28180                         Colors           []color.NRGBA
28181                         CollideWithAOs   bool
28182                         StepHeight       float32
28183                         FaceRotateDir    bool
28184                         FaceRotateDirOff float32 // in degrees.
28185                         BackfaceCull     bool
28186                         Nametag          string
28187                         NametagColor     color.NRGBA
28188                         FaceRotateSpeed  float32 // in degrees per second.
28189                         Infotext         string
28190                         Itemstring       string
28191                         Glow             int8
28192                         MaxBreath        uint16  // Player only.
28193                         EyeHeight        float32 // Player only.
28194                         ZoomFOV          float32 // in degrees. Player only.
28195                         UseTextureAlpha  bool
28196                         DmgTextureMod    Texture // suffix
28197                         Shaded           bool
28198                         ShowOnMinimap    bool
28199                         NametagBG        color.NRGBA
28200                 }))(obj)).RotateSpeed
28201                 write32(w, math.Float32bits(x))
28202         }
28203         if len(([]byte((*(*(struct {
28204                 MaxHP            uint16 // Player only.
28205                 CollideWithNodes bool
28206                 Weight           float32 // deprecated
28207                 ColBox, SelBox   Box
28208                 Pointable        bool
28209                 Visual           string
28210                 VisualSize       [3]float32
28211                 Textures         []Texture
28212                 SpriteSheetSize  [2]int16 // in sprites.
28213                 SpritePos        [2]int16 // in sprite sheet.
28214                 Visible          bool
28215                 MakeFootstepSnds bool
28216                 RotateSpeed      float32 // in radians per second.
28217                 Mesh             string
28218                 Colors           []color.NRGBA
28219                 CollideWithAOs   bool
28220                 StepHeight       float32
28221                 FaceRotateDir    bool
28222                 FaceRotateDirOff float32 // in degrees.
28223                 BackfaceCull     bool
28224                 Nametag          string
28225                 NametagColor     color.NRGBA
28226                 FaceRotateSpeed  float32 // in degrees per second.
28227                 Infotext         string
28228                 Itemstring       string
28229                 Glow             int8
28230                 MaxBreath        uint16  // Player only.
28231                 EyeHeight        float32 // Player only.
28232                 ZoomFOV          float32 // in degrees. Player only.
28233                 UseTextureAlpha  bool
28234                 DmgTextureMod    Texture // suffix
28235                 Shaded           bool
28236                 ShowOnMinimap    bool
28237                 NametagBG        color.NRGBA
28238         }))(obj)).Mesh))) > math.MaxUint16 {
28239                 chk(ErrTooLong)
28240         }
28241         {
28242                 x := uint16(len(([]byte((*(*(struct {
28243                         MaxHP            uint16 // Player only.
28244                         CollideWithNodes bool
28245                         Weight           float32 // deprecated
28246                         ColBox, SelBox   Box
28247                         Pointable        bool
28248                         Visual           string
28249                         VisualSize       [3]float32
28250                         Textures         []Texture
28251                         SpriteSheetSize  [2]int16 // in sprites.
28252                         SpritePos        [2]int16 // in sprite sheet.
28253                         Visible          bool
28254                         MakeFootstepSnds bool
28255                         RotateSpeed      float32 // in radians per second.
28256                         Mesh             string
28257                         Colors           []color.NRGBA
28258                         CollideWithAOs   bool
28259                         StepHeight       float32
28260                         FaceRotateDir    bool
28261                         FaceRotateDirOff float32 // in degrees.
28262                         BackfaceCull     bool
28263                         Nametag          string
28264                         NametagColor     color.NRGBA
28265                         FaceRotateSpeed  float32 // in degrees per second.
28266                         Infotext         string
28267                         Itemstring       string
28268                         Glow             int8
28269                         MaxBreath        uint16  // Player only.
28270                         EyeHeight        float32 // Player only.
28271                         ZoomFOV          float32 // in degrees. Player only.
28272                         UseTextureAlpha  bool
28273                         DmgTextureMod    Texture // suffix
28274                         Shaded           bool
28275                         ShowOnMinimap    bool
28276                         NametagBG        color.NRGBA
28277                 }))(obj)).Mesh))))
28278                 write16(w, uint16(x))
28279         }
28280         {
28281                 _, err := w.Write(([]byte((*(*(struct {
28282                         MaxHP            uint16 // Player only.
28283                         CollideWithNodes bool
28284                         Weight           float32 // deprecated
28285                         ColBox, SelBox   Box
28286                         Pointable        bool
28287                         Visual           string
28288                         VisualSize       [3]float32
28289                         Textures         []Texture
28290                         SpriteSheetSize  [2]int16 // in sprites.
28291                         SpritePos        [2]int16 // in sprite sheet.
28292                         Visible          bool
28293                         MakeFootstepSnds bool
28294                         RotateSpeed      float32 // in radians per second.
28295                         Mesh             string
28296                         Colors           []color.NRGBA
28297                         CollideWithAOs   bool
28298                         StepHeight       float32
28299                         FaceRotateDir    bool
28300                         FaceRotateDirOff float32 // in degrees.
28301                         BackfaceCull     bool
28302                         Nametag          string
28303                         NametagColor     color.NRGBA
28304                         FaceRotateSpeed  float32 // in degrees per second.
28305                         Infotext         string
28306                         Itemstring       string
28307                         Glow             int8
28308                         MaxBreath        uint16  // Player only.
28309                         EyeHeight        float32 // Player only.
28310                         ZoomFOV          float32 // in degrees. Player only.
28311                         UseTextureAlpha  bool
28312                         DmgTextureMod    Texture // suffix
28313                         Shaded           bool
28314                         ShowOnMinimap    bool
28315                         NametagBG        color.NRGBA
28316                 }))(obj)).Mesh))[:])
28317                 chk(err)
28318         }
28319         if len(((*(*(struct {
28320                 MaxHP            uint16 // Player only.
28321                 CollideWithNodes bool
28322                 Weight           float32 // deprecated
28323                 ColBox, SelBox   Box
28324                 Pointable        bool
28325                 Visual           string
28326                 VisualSize       [3]float32
28327                 Textures         []Texture
28328                 SpriteSheetSize  [2]int16 // in sprites.
28329                 SpritePos        [2]int16 // in sprite sheet.
28330                 Visible          bool
28331                 MakeFootstepSnds bool
28332                 RotateSpeed      float32 // in radians per second.
28333                 Mesh             string
28334                 Colors           []color.NRGBA
28335                 CollideWithAOs   bool
28336                 StepHeight       float32
28337                 FaceRotateDir    bool
28338                 FaceRotateDirOff float32 // in degrees.
28339                 BackfaceCull     bool
28340                 Nametag          string
28341                 NametagColor     color.NRGBA
28342                 FaceRotateSpeed  float32 // in degrees per second.
28343                 Infotext         string
28344                 Itemstring       string
28345                 Glow             int8
28346                 MaxBreath        uint16  // Player only.
28347                 EyeHeight        float32 // Player only.
28348                 ZoomFOV          float32 // in degrees. Player only.
28349                 UseTextureAlpha  bool
28350                 DmgTextureMod    Texture // suffix
28351                 Shaded           bool
28352                 ShowOnMinimap    bool
28353                 NametagBG        color.NRGBA
28354         }))(obj)).Colors)) > math.MaxUint16 {
28355                 chk(ErrTooLong)
28356         }
28357         {
28358                 x := uint16(len(((*(*(struct {
28359                         MaxHP            uint16 // Player only.
28360                         CollideWithNodes bool
28361                         Weight           float32 // deprecated
28362                         ColBox, SelBox   Box
28363                         Pointable        bool
28364                         Visual           string
28365                         VisualSize       [3]float32
28366                         Textures         []Texture
28367                         SpriteSheetSize  [2]int16 // in sprites.
28368                         SpritePos        [2]int16 // in sprite sheet.
28369                         Visible          bool
28370                         MakeFootstepSnds bool
28371                         RotateSpeed      float32 // in radians per second.
28372                         Mesh             string
28373                         Colors           []color.NRGBA
28374                         CollideWithAOs   bool
28375                         StepHeight       float32
28376                         FaceRotateDir    bool
28377                         FaceRotateDirOff float32 // in degrees.
28378                         BackfaceCull     bool
28379                         Nametag          string
28380                         NametagColor     color.NRGBA
28381                         FaceRotateSpeed  float32 // in degrees per second.
28382                         Infotext         string
28383                         Itemstring       string
28384                         Glow             int8
28385                         MaxBreath        uint16  // Player only.
28386                         EyeHeight        float32 // Player only.
28387                         ZoomFOV          float32 // in degrees. Player only.
28388                         UseTextureAlpha  bool
28389                         DmgTextureMod    Texture // suffix
28390                         Shaded           bool
28391                         ShowOnMinimap    bool
28392                         NametagBG        color.NRGBA
28393                 }))(obj)).Colors)))
28394                 write16(w, uint16(x))
28395         }
28396         for local338 := range (*(*(struct {
28397                 MaxHP            uint16 // Player only.
28398                 CollideWithNodes bool
28399                 Weight           float32 // deprecated
28400                 ColBox, SelBox   Box
28401                 Pointable        bool
28402                 Visual           string
28403                 VisualSize       [3]float32
28404                 Textures         []Texture
28405                 SpriteSheetSize  [2]int16 // in sprites.
28406                 SpritePos        [2]int16 // in sprite sheet.
28407                 Visible          bool
28408                 MakeFootstepSnds bool
28409                 RotateSpeed      float32 // in radians per second.
28410                 Mesh             string
28411                 Colors           []color.NRGBA
28412                 CollideWithAOs   bool
28413                 StepHeight       float32
28414                 FaceRotateDir    bool
28415                 FaceRotateDirOff float32 // in degrees.
28416                 BackfaceCull     bool
28417                 Nametag          string
28418                 NametagColor     color.NRGBA
28419                 FaceRotateSpeed  float32 // in degrees per second.
28420                 Infotext         string
28421                 Itemstring       string
28422                 Glow             int8
28423                 MaxBreath        uint16  // Player only.
28424                 EyeHeight        float32 // Player only.
28425                 ZoomFOV          float32 // in degrees. Player only.
28426                 UseTextureAlpha  bool
28427                 DmgTextureMod    Texture // suffix
28428                 Shaded           bool
28429                 ShowOnMinimap    bool
28430                 NametagBG        color.NRGBA
28431         }))(obj)).Colors {
28432                 {
28433                         x := ((*(*(struct {
28434                                 MaxHP            uint16 // Player only.
28435                                 CollideWithNodes bool
28436                                 Weight           float32 // deprecated
28437                                 ColBox, SelBox   Box
28438                                 Pointable        bool
28439                                 Visual           string
28440                                 VisualSize       [3]float32
28441                                 Textures         []Texture
28442                                 SpriteSheetSize  [2]int16 // in sprites.
28443                                 SpritePos        [2]int16 // in sprite sheet.
28444                                 Visible          bool
28445                                 MakeFootstepSnds bool
28446                                 RotateSpeed      float32 // in radians per second.
28447                                 Mesh             string
28448                                 Colors           []color.NRGBA
28449                                 CollideWithAOs   bool
28450                                 StepHeight       float32
28451                                 FaceRotateDir    bool
28452                                 FaceRotateDirOff float32 // in degrees.
28453                                 BackfaceCull     bool
28454                                 Nametag          string
28455                                 NametagColor     color.NRGBA
28456                                 FaceRotateSpeed  float32 // in degrees per second.
28457                                 Infotext         string
28458                                 Itemstring       string
28459                                 Glow             int8
28460                                 MaxBreath        uint16  // Player only.
28461                                 EyeHeight        float32 // Player only.
28462                                 ZoomFOV          float32 // in degrees. Player only.
28463                                 UseTextureAlpha  bool
28464                                 DmgTextureMod    Texture // suffix
28465                                 Shaded           bool
28466                                 ShowOnMinimap    bool
28467                                 NametagBG        color.NRGBA
28468                         }))(obj)).Colors)[local338]
28469                         w.Write([]byte{x.A, x.R, x.G, x.B})
28470                 }
28471         }
28472         {
28473                 x := (*(*(struct {
28474                         MaxHP            uint16 // Player only.
28475                         CollideWithNodes bool
28476                         Weight           float32 // deprecated
28477                         ColBox, SelBox   Box
28478                         Pointable        bool
28479                         Visual           string
28480                         VisualSize       [3]float32
28481                         Textures         []Texture
28482                         SpriteSheetSize  [2]int16 // in sprites.
28483                         SpritePos        [2]int16 // in sprite sheet.
28484                         Visible          bool
28485                         MakeFootstepSnds bool
28486                         RotateSpeed      float32 // in radians per second.
28487                         Mesh             string
28488                         Colors           []color.NRGBA
28489                         CollideWithAOs   bool
28490                         StepHeight       float32
28491                         FaceRotateDir    bool
28492                         FaceRotateDirOff float32 // in degrees.
28493                         BackfaceCull     bool
28494                         Nametag          string
28495                         NametagColor     color.NRGBA
28496                         FaceRotateSpeed  float32 // in degrees per second.
28497                         Infotext         string
28498                         Itemstring       string
28499                         Glow             int8
28500                         MaxBreath        uint16  // Player only.
28501                         EyeHeight        float32 // Player only.
28502                         ZoomFOV          float32 // in degrees. Player only.
28503                         UseTextureAlpha  bool
28504                         DmgTextureMod    Texture // suffix
28505                         Shaded           bool
28506                         ShowOnMinimap    bool
28507                         NametagBG        color.NRGBA
28508                 }))(obj)).CollideWithAOs
28509                 if x {
28510                         write8(w, 1)
28511                 } else {
28512                         write8(w, 0)
28513                 }
28514         }
28515         {
28516                 x := (*(*(struct {
28517                         MaxHP            uint16 // Player only.
28518                         CollideWithNodes bool
28519                         Weight           float32 // deprecated
28520                         ColBox, SelBox   Box
28521                         Pointable        bool
28522                         Visual           string
28523                         VisualSize       [3]float32
28524                         Textures         []Texture
28525                         SpriteSheetSize  [2]int16 // in sprites.
28526                         SpritePos        [2]int16 // in sprite sheet.
28527                         Visible          bool
28528                         MakeFootstepSnds bool
28529                         RotateSpeed      float32 // in radians per second.
28530                         Mesh             string
28531                         Colors           []color.NRGBA
28532                         CollideWithAOs   bool
28533                         StepHeight       float32
28534                         FaceRotateDir    bool
28535                         FaceRotateDirOff float32 // in degrees.
28536                         BackfaceCull     bool
28537                         Nametag          string
28538                         NametagColor     color.NRGBA
28539                         FaceRotateSpeed  float32 // in degrees per second.
28540                         Infotext         string
28541                         Itemstring       string
28542                         Glow             int8
28543                         MaxBreath        uint16  // Player only.
28544                         EyeHeight        float32 // Player only.
28545                         ZoomFOV          float32 // in degrees. Player only.
28546                         UseTextureAlpha  bool
28547                         DmgTextureMod    Texture // suffix
28548                         Shaded           bool
28549                         ShowOnMinimap    bool
28550                         NametagBG        color.NRGBA
28551                 }))(obj)).StepHeight
28552                 write32(w, math.Float32bits(x))
28553         }
28554         {
28555                 x := (*(*(struct {
28556                         MaxHP            uint16 // Player only.
28557                         CollideWithNodes bool
28558                         Weight           float32 // deprecated
28559                         ColBox, SelBox   Box
28560                         Pointable        bool
28561                         Visual           string
28562                         VisualSize       [3]float32
28563                         Textures         []Texture
28564                         SpriteSheetSize  [2]int16 // in sprites.
28565                         SpritePos        [2]int16 // in sprite sheet.
28566                         Visible          bool
28567                         MakeFootstepSnds bool
28568                         RotateSpeed      float32 // in radians per second.
28569                         Mesh             string
28570                         Colors           []color.NRGBA
28571                         CollideWithAOs   bool
28572                         StepHeight       float32
28573                         FaceRotateDir    bool
28574                         FaceRotateDirOff float32 // in degrees.
28575                         BackfaceCull     bool
28576                         Nametag          string
28577                         NametagColor     color.NRGBA
28578                         FaceRotateSpeed  float32 // in degrees per second.
28579                         Infotext         string
28580                         Itemstring       string
28581                         Glow             int8
28582                         MaxBreath        uint16  // Player only.
28583                         EyeHeight        float32 // Player only.
28584                         ZoomFOV          float32 // in degrees. Player only.
28585                         UseTextureAlpha  bool
28586                         DmgTextureMod    Texture // suffix
28587                         Shaded           bool
28588                         ShowOnMinimap    bool
28589                         NametagBG        color.NRGBA
28590                 }))(obj)).FaceRotateDir
28591                 if x {
28592                         write8(w, 1)
28593                 } else {
28594                         write8(w, 0)
28595                 }
28596         }
28597         {
28598                 x := (*(*(struct {
28599                         MaxHP            uint16 // Player only.
28600                         CollideWithNodes bool
28601                         Weight           float32 // deprecated
28602                         ColBox, SelBox   Box
28603                         Pointable        bool
28604                         Visual           string
28605                         VisualSize       [3]float32
28606                         Textures         []Texture
28607                         SpriteSheetSize  [2]int16 // in sprites.
28608                         SpritePos        [2]int16 // in sprite sheet.
28609                         Visible          bool
28610                         MakeFootstepSnds bool
28611                         RotateSpeed      float32 // in radians per second.
28612                         Mesh             string
28613                         Colors           []color.NRGBA
28614                         CollideWithAOs   bool
28615                         StepHeight       float32
28616                         FaceRotateDir    bool
28617                         FaceRotateDirOff float32 // in degrees.
28618                         BackfaceCull     bool
28619                         Nametag          string
28620                         NametagColor     color.NRGBA
28621                         FaceRotateSpeed  float32 // in degrees per second.
28622                         Infotext         string
28623                         Itemstring       string
28624                         Glow             int8
28625                         MaxBreath        uint16  // Player only.
28626                         EyeHeight        float32 // Player only.
28627                         ZoomFOV          float32 // in degrees. Player only.
28628                         UseTextureAlpha  bool
28629                         DmgTextureMod    Texture // suffix
28630                         Shaded           bool
28631                         ShowOnMinimap    bool
28632                         NametagBG        color.NRGBA
28633                 }))(obj)).FaceRotateDirOff
28634                 write32(w, math.Float32bits(x))
28635         }
28636         {
28637                 x := (*(*(struct {
28638                         MaxHP            uint16 // Player only.
28639                         CollideWithNodes bool
28640                         Weight           float32 // deprecated
28641                         ColBox, SelBox   Box
28642                         Pointable        bool
28643                         Visual           string
28644                         VisualSize       [3]float32
28645                         Textures         []Texture
28646                         SpriteSheetSize  [2]int16 // in sprites.
28647                         SpritePos        [2]int16 // in sprite sheet.
28648                         Visible          bool
28649                         MakeFootstepSnds bool
28650                         RotateSpeed      float32 // in radians per second.
28651                         Mesh             string
28652                         Colors           []color.NRGBA
28653                         CollideWithAOs   bool
28654                         StepHeight       float32
28655                         FaceRotateDir    bool
28656                         FaceRotateDirOff float32 // in degrees.
28657                         BackfaceCull     bool
28658                         Nametag          string
28659                         NametagColor     color.NRGBA
28660                         FaceRotateSpeed  float32 // in degrees per second.
28661                         Infotext         string
28662                         Itemstring       string
28663                         Glow             int8
28664                         MaxBreath        uint16  // Player only.
28665                         EyeHeight        float32 // Player only.
28666                         ZoomFOV          float32 // in degrees. Player only.
28667                         UseTextureAlpha  bool
28668                         DmgTextureMod    Texture // suffix
28669                         Shaded           bool
28670                         ShowOnMinimap    bool
28671                         NametagBG        color.NRGBA
28672                 }))(obj)).BackfaceCull
28673                 if x {
28674                         write8(w, 1)
28675                 } else {
28676                         write8(w, 0)
28677                 }
28678         }
28679         if len(([]byte((*(*(struct {
28680                 MaxHP            uint16 // Player only.
28681                 CollideWithNodes bool
28682                 Weight           float32 // deprecated
28683                 ColBox, SelBox   Box
28684                 Pointable        bool
28685                 Visual           string
28686                 VisualSize       [3]float32
28687                 Textures         []Texture
28688                 SpriteSheetSize  [2]int16 // in sprites.
28689                 SpritePos        [2]int16 // in sprite sheet.
28690                 Visible          bool
28691                 MakeFootstepSnds bool
28692                 RotateSpeed      float32 // in radians per second.
28693                 Mesh             string
28694                 Colors           []color.NRGBA
28695                 CollideWithAOs   bool
28696                 StepHeight       float32
28697                 FaceRotateDir    bool
28698                 FaceRotateDirOff float32 // in degrees.
28699                 BackfaceCull     bool
28700                 Nametag          string
28701                 NametagColor     color.NRGBA
28702                 FaceRotateSpeed  float32 // in degrees per second.
28703                 Infotext         string
28704                 Itemstring       string
28705                 Glow             int8
28706                 MaxBreath        uint16  // Player only.
28707                 EyeHeight        float32 // Player only.
28708                 ZoomFOV          float32 // in degrees. Player only.
28709                 UseTextureAlpha  bool
28710                 DmgTextureMod    Texture // suffix
28711                 Shaded           bool
28712                 ShowOnMinimap    bool
28713                 NametagBG        color.NRGBA
28714         }))(obj)).Nametag))) > math.MaxUint16 {
28715                 chk(ErrTooLong)
28716         }
28717         {
28718                 x := uint16(len(([]byte((*(*(struct {
28719                         MaxHP            uint16 // Player only.
28720                         CollideWithNodes bool
28721                         Weight           float32 // deprecated
28722                         ColBox, SelBox   Box
28723                         Pointable        bool
28724                         Visual           string
28725                         VisualSize       [3]float32
28726                         Textures         []Texture
28727                         SpriteSheetSize  [2]int16 // in sprites.
28728                         SpritePos        [2]int16 // in sprite sheet.
28729                         Visible          bool
28730                         MakeFootstepSnds bool
28731                         RotateSpeed      float32 // in radians per second.
28732                         Mesh             string
28733                         Colors           []color.NRGBA
28734                         CollideWithAOs   bool
28735                         StepHeight       float32
28736                         FaceRotateDir    bool
28737                         FaceRotateDirOff float32 // in degrees.
28738                         BackfaceCull     bool
28739                         Nametag          string
28740                         NametagColor     color.NRGBA
28741                         FaceRotateSpeed  float32 // in degrees per second.
28742                         Infotext         string
28743                         Itemstring       string
28744                         Glow             int8
28745                         MaxBreath        uint16  // Player only.
28746                         EyeHeight        float32 // Player only.
28747                         ZoomFOV          float32 // in degrees. Player only.
28748                         UseTextureAlpha  bool
28749                         DmgTextureMod    Texture // suffix
28750                         Shaded           bool
28751                         ShowOnMinimap    bool
28752                         NametagBG        color.NRGBA
28753                 }))(obj)).Nametag))))
28754                 write16(w, uint16(x))
28755         }
28756         {
28757                 _, err := w.Write(([]byte((*(*(struct {
28758                         MaxHP            uint16 // Player only.
28759                         CollideWithNodes bool
28760                         Weight           float32 // deprecated
28761                         ColBox, SelBox   Box
28762                         Pointable        bool
28763                         Visual           string
28764                         VisualSize       [3]float32
28765                         Textures         []Texture
28766                         SpriteSheetSize  [2]int16 // in sprites.
28767                         SpritePos        [2]int16 // in sprite sheet.
28768                         Visible          bool
28769                         MakeFootstepSnds bool
28770                         RotateSpeed      float32 // in radians per second.
28771                         Mesh             string
28772                         Colors           []color.NRGBA
28773                         CollideWithAOs   bool
28774                         StepHeight       float32
28775                         FaceRotateDir    bool
28776                         FaceRotateDirOff float32 // in degrees.
28777                         BackfaceCull     bool
28778                         Nametag          string
28779                         NametagColor     color.NRGBA
28780                         FaceRotateSpeed  float32 // in degrees per second.
28781                         Infotext         string
28782                         Itemstring       string
28783                         Glow             int8
28784                         MaxBreath        uint16  // Player only.
28785                         EyeHeight        float32 // Player only.
28786                         ZoomFOV          float32 // in degrees. Player only.
28787                         UseTextureAlpha  bool
28788                         DmgTextureMod    Texture // suffix
28789                         Shaded           bool
28790                         ShowOnMinimap    bool
28791                         NametagBG        color.NRGBA
28792                 }))(obj)).Nametag))[:])
28793                 chk(err)
28794         }
28795         {
28796                 x := (*(*(struct {
28797                         MaxHP            uint16 // Player only.
28798                         CollideWithNodes bool
28799                         Weight           float32 // deprecated
28800                         ColBox, SelBox   Box
28801                         Pointable        bool
28802                         Visual           string
28803                         VisualSize       [3]float32
28804                         Textures         []Texture
28805                         SpriteSheetSize  [2]int16 // in sprites.
28806                         SpritePos        [2]int16 // in sprite sheet.
28807                         Visible          bool
28808                         MakeFootstepSnds bool
28809                         RotateSpeed      float32 // in radians per second.
28810                         Mesh             string
28811                         Colors           []color.NRGBA
28812                         CollideWithAOs   bool
28813                         StepHeight       float32
28814                         FaceRotateDir    bool
28815                         FaceRotateDirOff float32 // in degrees.
28816                         BackfaceCull     bool
28817                         Nametag          string
28818                         NametagColor     color.NRGBA
28819                         FaceRotateSpeed  float32 // in degrees per second.
28820                         Infotext         string
28821                         Itemstring       string
28822                         Glow             int8
28823                         MaxBreath        uint16  // Player only.
28824                         EyeHeight        float32 // Player only.
28825                         ZoomFOV          float32 // in degrees. Player only.
28826                         UseTextureAlpha  bool
28827                         DmgTextureMod    Texture // suffix
28828                         Shaded           bool
28829                         ShowOnMinimap    bool
28830                         NametagBG        color.NRGBA
28831                 }))(obj)).NametagColor
28832                 w.Write([]byte{x.A, x.R, x.G, x.B})
28833         }
28834         {
28835                 x := (*(*(struct {
28836                         MaxHP            uint16 // Player only.
28837                         CollideWithNodes bool
28838                         Weight           float32 // deprecated
28839                         ColBox, SelBox   Box
28840                         Pointable        bool
28841                         Visual           string
28842                         VisualSize       [3]float32
28843                         Textures         []Texture
28844                         SpriteSheetSize  [2]int16 // in sprites.
28845                         SpritePos        [2]int16 // in sprite sheet.
28846                         Visible          bool
28847                         MakeFootstepSnds bool
28848                         RotateSpeed      float32 // in radians per second.
28849                         Mesh             string
28850                         Colors           []color.NRGBA
28851                         CollideWithAOs   bool
28852                         StepHeight       float32
28853                         FaceRotateDir    bool
28854                         FaceRotateDirOff float32 // in degrees.
28855                         BackfaceCull     bool
28856                         Nametag          string
28857                         NametagColor     color.NRGBA
28858                         FaceRotateSpeed  float32 // in degrees per second.
28859                         Infotext         string
28860                         Itemstring       string
28861                         Glow             int8
28862                         MaxBreath        uint16  // Player only.
28863                         EyeHeight        float32 // Player only.
28864                         ZoomFOV          float32 // in degrees. Player only.
28865                         UseTextureAlpha  bool
28866                         DmgTextureMod    Texture // suffix
28867                         Shaded           bool
28868                         ShowOnMinimap    bool
28869                         NametagBG        color.NRGBA
28870                 }))(obj)).FaceRotateSpeed
28871                 write32(w, math.Float32bits(x))
28872         }
28873         if len(([]byte((*(*(struct {
28874                 MaxHP            uint16 // Player only.
28875                 CollideWithNodes bool
28876                 Weight           float32 // deprecated
28877                 ColBox, SelBox   Box
28878                 Pointable        bool
28879                 Visual           string
28880                 VisualSize       [3]float32
28881                 Textures         []Texture
28882                 SpriteSheetSize  [2]int16 // in sprites.
28883                 SpritePos        [2]int16 // in sprite sheet.
28884                 Visible          bool
28885                 MakeFootstepSnds bool
28886                 RotateSpeed      float32 // in radians per second.
28887                 Mesh             string
28888                 Colors           []color.NRGBA
28889                 CollideWithAOs   bool
28890                 StepHeight       float32
28891                 FaceRotateDir    bool
28892                 FaceRotateDirOff float32 // in degrees.
28893                 BackfaceCull     bool
28894                 Nametag          string
28895                 NametagColor     color.NRGBA
28896                 FaceRotateSpeed  float32 // in degrees per second.
28897                 Infotext         string
28898                 Itemstring       string
28899                 Glow             int8
28900                 MaxBreath        uint16  // Player only.
28901                 EyeHeight        float32 // Player only.
28902                 ZoomFOV          float32 // in degrees. Player only.
28903                 UseTextureAlpha  bool
28904                 DmgTextureMod    Texture // suffix
28905                 Shaded           bool
28906                 ShowOnMinimap    bool
28907                 NametagBG        color.NRGBA
28908         }))(obj)).Infotext))) > math.MaxUint16 {
28909                 chk(ErrTooLong)
28910         }
28911         {
28912                 x := uint16(len(([]byte((*(*(struct {
28913                         MaxHP            uint16 // Player only.
28914                         CollideWithNodes bool
28915                         Weight           float32 // deprecated
28916                         ColBox, SelBox   Box
28917                         Pointable        bool
28918                         Visual           string
28919                         VisualSize       [3]float32
28920                         Textures         []Texture
28921                         SpriteSheetSize  [2]int16 // in sprites.
28922                         SpritePos        [2]int16 // in sprite sheet.
28923                         Visible          bool
28924                         MakeFootstepSnds bool
28925                         RotateSpeed      float32 // in radians per second.
28926                         Mesh             string
28927                         Colors           []color.NRGBA
28928                         CollideWithAOs   bool
28929                         StepHeight       float32
28930                         FaceRotateDir    bool
28931                         FaceRotateDirOff float32 // in degrees.
28932                         BackfaceCull     bool
28933                         Nametag          string
28934                         NametagColor     color.NRGBA
28935                         FaceRotateSpeed  float32 // in degrees per second.
28936                         Infotext         string
28937                         Itemstring       string
28938                         Glow             int8
28939                         MaxBreath        uint16  // Player only.
28940                         EyeHeight        float32 // Player only.
28941                         ZoomFOV          float32 // in degrees. Player only.
28942                         UseTextureAlpha  bool
28943                         DmgTextureMod    Texture // suffix
28944                         Shaded           bool
28945                         ShowOnMinimap    bool
28946                         NametagBG        color.NRGBA
28947                 }))(obj)).Infotext))))
28948                 write16(w, uint16(x))
28949         }
28950         {
28951                 _, err := w.Write(([]byte((*(*(struct {
28952                         MaxHP            uint16 // Player only.
28953                         CollideWithNodes bool
28954                         Weight           float32 // deprecated
28955                         ColBox, SelBox   Box
28956                         Pointable        bool
28957                         Visual           string
28958                         VisualSize       [3]float32
28959                         Textures         []Texture
28960                         SpriteSheetSize  [2]int16 // in sprites.
28961                         SpritePos        [2]int16 // in sprite sheet.
28962                         Visible          bool
28963                         MakeFootstepSnds bool
28964                         RotateSpeed      float32 // in radians per second.
28965                         Mesh             string
28966                         Colors           []color.NRGBA
28967                         CollideWithAOs   bool
28968                         StepHeight       float32
28969                         FaceRotateDir    bool
28970                         FaceRotateDirOff float32 // in degrees.
28971                         BackfaceCull     bool
28972                         Nametag          string
28973                         NametagColor     color.NRGBA
28974                         FaceRotateSpeed  float32 // in degrees per second.
28975                         Infotext         string
28976                         Itemstring       string
28977                         Glow             int8
28978                         MaxBreath        uint16  // Player only.
28979                         EyeHeight        float32 // Player only.
28980                         ZoomFOV          float32 // in degrees. Player only.
28981                         UseTextureAlpha  bool
28982                         DmgTextureMod    Texture // suffix
28983                         Shaded           bool
28984                         ShowOnMinimap    bool
28985                         NametagBG        color.NRGBA
28986                 }))(obj)).Infotext))[:])
28987                 chk(err)
28988         }
28989         if len(([]byte((*(*(struct {
28990                 MaxHP            uint16 // Player only.
28991                 CollideWithNodes bool
28992                 Weight           float32 // deprecated
28993                 ColBox, SelBox   Box
28994                 Pointable        bool
28995                 Visual           string
28996                 VisualSize       [3]float32
28997                 Textures         []Texture
28998                 SpriteSheetSize  [2]int16 // in sprites.
28999                 SpritePos        [2]int16 // in sprite sheet.
29000                 Visible          bool
29001                 MakeFootstepSnds bool
29002                 RotateSpeed      float32 // in radians per second.
29003                 Mesh             string
29004                 Colors           []color.NRGBA
29005                 CollideWithAOs   bool
29006                 StepHeight       float32
29007                 FaceRotateDir    bool
29008                 FaceRotateDirOff float32 // in degrees.
29009                 BackfaceCull     bool
29010                 Nametag          string
29011                 NametagColor     color.NRGBA
29012                 FaceRotateSpeed  float32 // in degrees per second.
29013                 Infotext         string
29014                 Itemstring       string
29015                 Glow             int8
29016                 MaxBreath        uint16  // Player only.
29017                 EyeHeight        float32 // Player only.
29018                 ZoomFOV          float32 // in degrees. Player only.
29019                 UseTextureAlpha  bool
29020                 DmgTextureMod    Texture // suffix
29021                 Shaded           bool
29022                 ShowOnMinimap    bool
29023                 NametagBG        color.NRGBA
29024         }))(obj)).Itemstring))) > math.MaxUint16 {
29025                 chk(ErrTooLong)
29026         }
29027         {
29028                 x := uint16(len(([]byte((*(*(struct {
29029                         MaxHP            uint16 // Player only.
29030                         CollideWithNodes bool
29031                         Weight           float32 // deprecated
29032                         ColBox, SelBox   Box
29033                         Pointable        bool
29034                         Visual           string
29035                         VisualSize       [3]float32
29036                         Textures         []Texture
29037                         SpriteSheetSize  [2]int16 // in sprites.
29038                         SpritePos        [2]int16 // in sprite sheet.
29039                         Visible          bool
29040                         MakeFootstepSnds bool
29041                         RotateSpeed      float32 // in radians per second.
29042                         Mesh             string
29043                         Colors           []color.NRGBA
29044                         CollideWithAOs   bool
29045                         StepHeight       float32
29046                         FaceRotateDir    bool
29047                         FaceRotateDirOff float32 // in degrees.
29048                         BackfaceCull     bool
29049                         Nametag          string
29050                         NametagColor     color.NRGBA
29051                         FaceRotateSpeed  float32 // in degrees per second.
29052                         Infotext         string
29053                         Itemstring       string
29054                         Glow             int8
29055                         MaxBreath        uint16  // Player only.
29056                         EyeHeight        float32 // Player only.
29057                         ZoomFOV          float32 // in degrees. Player only.
29058                         UseTextureAlpha  bool
29059                         DmgTextureMod    Texture // suffix
29060                         Shaded           bool
29061                         ShowOnMinimap    bool
29062                         NametagBG        color.NRGBA
29063                 }))(obj)).Itemstring))))
29064                 write16(w, uint16(x))
29065         }
29066         {
29067                 _, err := w.Write(([]byte((*(*(struct {
29068                         MaxHP            uint16 // Player only.
29069                         CollideWithNodes bool
29070                         Weight           float32 // deprecated
29071                         ColBox, SelBox   Box
29072                         Pointable        bool
29073                         Visual           string
29074                         VisualSize       [3]float32
29075                         Textures         []Texture
29076                         SpriteSheetSize  [2]int16 // in sprites.
29077                         SpritePos        [2]int16 // in sprite sheet.
29078                         Visible          bool
29079                         MakeFootstepSnds bool
29080                         RotateSpeed      float32 // in radians per second.
29081                         Mesh             string
29082                         Colors           []color.NRGBA
29083                         CollideWithAOs   bool
29084                         StepHeight       float32
29085                         FaceRotateDir    bool
29086                         FaceRotateDirOff float32 // in degrees.
29087                         BackfaceCull     bool
29088                         Nametag          string
29089                         NametagColor     color.NRGBA
29090                         FaceRotateSpeed  float32 // in degrees per second.
29091                         Infotext         string
29092                         Itemstring       string
29093                         Glow             int8
29094                         MaxBreath        uint16  // Player only.
29095                         EyeHeight        float32 // Player only.
29096                         ZoomFOV          float32 // in degrees. Player only.
29097                         UseTextureAlpha  bool
29098                         DmgTextureMod    Texture // suffix
29099                         Shaded           bool
29100                         ShowOnMinimap    bool
29101                         NametagBG        color.NRGBA
29102                 }))(obj)).Itemstring))[:])
29103                 chk(err)
29104         }
29105         {
29106                 x := (*(*(struct {
29107                         MaxHP            uint16 // Player only.
29108                         CollideWithNodes bool
29109                         Weight           float32 // deprecated
29110                         ColBox, SelBox   Box
29111                         Pointable        bool
29112                         Visual           string
29113                         VisualSize       [3]float32
29114                         Textures         []Texture
29115                         SpriteSheetSize  [2]int16 // in sprites.
29116                         SpritePos        [2]int16 // in sprite sheet.
29117                         Visible          bool
29118                         MakeFootstepSnds bool
29119                         RotateSpeed      float32 // in radians per second.
29120                         Mesh             string
29121                         Colors           []color.NRGBA
29122                         CollideWithAOs   bool
29123                         StepHeight       float32
29124                         FaceRotateDir    bool
29125                         FaceRotateDirOff float32 // in degrees.
29126                         BackfaceCull     bool
29127                         Nametag          string
29128                         NametagColor     color.NRGBA
29129                         FaceRotateSpeed  float32 // in degrees per second.
29130                         Infotext         string
29131                         Itemstring       string
29132                         Glow             int8
29133                         MaxBreath        uint16  // Player only.
29134                         EyeHeight        float32 // Player only.
29135                         ZoomFOV          float32 // in degrees. Player only.
29136                         UseTextureAlpha  bool
29137                         DmgTextureMod    Texture // suffix
29138                         Shaded           bool
29139                         ShowOnMinimap    bool
29140                         NametagBG        color.NRGBA
29141                 }))(obj)).Glow
29142                 write8(w, uint8(x))
29143         }
29144         {
29145                 x := (*(*(struct {
29146                         MaxHP            uint16 // Player only.
29147                         CollideWithNodes bool
29148                         Weight           float32 // deprecated
29149                         ColBox, SelBox   Box
29150                         Pointable        bool
29151                         Visual           string
29152                         VisualSize       [3]float32
29153                         Textures         []Texture
29154                         SpriteSheetSize  [2]int16 // in sprites.
29155                         SpritePos        [2]int16 // in sprite sheet.
29156                         Visible          bool
29157                         MakeFootstepSnds bool
29158                         RotateSpeed      float32 // in radians per second.
29159                         Mesh             string
29160                         Colors           []color.NRGBA
29161                         CollideWithAOs   bool
29162                         StepHeight       float32
29163                         FaceRotateDir    bool
29164                         FaceRotateDirOff float32 // in degrees.
29165                         BackfaceCull     bool
29166                         Nametag          string
29167                         NametagColor     color.NRGBA
29168                         FaceRotateSpeed  float32 // in degrees per second.
29169                         Infotext         string
29170                         Itemstring       string
29171                         Glow             int8
29172                         MaxBreath        uint16  // Player only.
29173                         EyeHeight        float32 // Player only.
29174                         ZoomFOV          float32 // in degrees. Player only.
29175                         UseTextureAlpha  bool
29176                         DmgTextureMod    Texture // suffix
29177                         Shaded           bool
29178                         ShowOnMinimap    bool
29179                         NametagBG        color.NRGBA
29180                 }))(obj)).MaxBreath
29181                 write16(w, uint16(x))
29182         }
29183         {
29184                 x := (*(*(struct {
29185                         MaxHP            uint16 // Player only.
29186                         CollideWithNodes bool
29187                         Weight           float32 // deprecated
29188                         ColBox, SelBox   Box
29189                         Pointable        bool
29190                         Visual           string
29191                         VisualSize       [3]float32
29192                         Textures         []Texture
29193                         SpriteSheetSize  [2]int16 // in sprites.
29194                         SpritePos        [2]int16 // in sprite sheet.
29195                         Visible          bool
29196                         MakeFootstepSnds bool
29197                         RotateSpeed      float32 // in radians per second.
29198                         Mesh             string
29199                         Colors           []color.NRGBA
29200                         CollideWithAOs   bool
29201                         StepHeight       float32
29202                         FaceRotateDir    bool
29203                         FaceRotateDirOff float32 // in degrees.
29204                         BackfaceCull     bool
29205                         Nametag          string
29206                         NametagColor     color.NRGBA
29207                         FaceRotateSpeed  float32 // in degrees per second.
29208                         Infotext         string
29209                         Itemstring       string
29210                         Glow             int8
29211                         MaxBreath        uint16  // Player only.
29212                         EyeHeight        float32 // Player only.
29213                         ZoomFOV          float32 // in degrees. Player only.
29214                         UseTextureAlpha  bool
29215                         DmgTextureMod    Texture // suffix
29216                         Shaded           bool
29217                         ShowOnMinimap    bool
29218                         NametagBG        color.NRGBA
29219                 }))(obj)).EyeHeight
29220                 write32(w, math.Float32bits(x))
29221         }
29222         {
29223                 x := (*(*(struct {
29224                         MaxHP            uint16 // Player only.
29225                         CollideWithNodes bool
29226                         Weight           float32 // deprecated
29227                         ColBox, SelBox   Box
29228                         Pointable        bool
29229                         Visual           string
29230                         VisualSize       [3]float32
29231                         Textures         []Texture
29232                         SpriteSheetSize  [2]int16 // in sprites.
29233                         SpritePos        [2]int16 // in sprite sheet.
29234                         Visible          bool
29235                         MakeFootstepSnds bool
29236                         RotateSpeed      float32 // in radians per second.
29237                         Mesh             string
29238                         Colors           []color.NRGBA
29239                         CollideWithAOs   bool
29240                         StepHeight       float32
29241                         FaceRotateDir    bool
29242                         FaceRotateDirOff float32 // in degrees.
29243                         BackfaceCull     bool
29244                         Nametag          string
29245                         NametagColor     color.NRGBA
29246                         FaceRotateSpeed  float32 // in degrees per second.
29247                         Infotext         string
29248                         Itemstring       string
29249                         Glow             int8
29250                         MaxBreath        uint16  // Player only.
29251                         EyeHeight        float32 // Player only.
29252                         ZoomFOV          float32 // in degrees. Player only.
29253                         UseTextureAlpha  bool
29254                         DmgTextureMod    Texture // suffix
29255                         Shaded           bool
29256                         ShowOnMinimap    bool
29257                         NametagBG        color.NRGBA
29258                 }))(obj)).ZoomFOV
29259                 write32(w, math.Float32bits(x))
29260         }
29261         {
29262                 x := (*(*(struct {
29263                         MaxHP            uint16 // Player only.
29264                         CollideWithNodes bool
29265                         Weight           float32 // deprecated
29266                         ColBox, SelBox   Box
29267                         Pointable        bool
29268                         Visual           string
29269                         VisualSize       [3]float32
29270                         Textures         []Texture
29271                         SpriteSheetSize  [2]int16 // in sprites.
29272                         SpritePos        [2]int16 // in sprite sheet.
29273                         Visible          bool
29274                         MakeFootstepSnds bool
29275                         RotateSpeed      float32 // in radians per second.
29276                         Mesh             string
29277                         Colors           []color.NRGBA
29278                         CollideWithAOs   bool
29279                         StepHeight       float32
29280                         FaceRotateDir    bool
29281                         FaceRotateDirOff float32 // in degrees.
29282                         BackfaceCull     bool
29283                         Nametag          string
29284                         NametagColor     color.NRGBA
29285                         FaceRotateSpeed  float32 // in degrees per second.
29286                         Infotext         string
29287                         Itemstring       string
29288                         Glow             int8
29289                         MaxBreath        uint16  // Player only.
29290                         EyeHeight        float32 // Player only.
29291                         ZoomFOV          float32 // in degrees. Player only.
29292                         UseTextureAlpha  bool
29293                         DmgTextureMod    Texture // suffix
29294                         Shaded           bool
29295                         ShowOnMinimap    bool
29296                         NametagBG        color.NRGBA
29297                 }))(obj)).UseTextureAlpha
29298                 if x {
29299                         write8(w, 1)
29300                 } else {
29301                         write8(w, 0)
29302                 }
29303         }
29304         if err := pcall(func() {
29305                 ((*(*(struct {
29306                         MaxHP            uint16 // Player only.
29307                         CollideWithNodes bool
29308                         Weight           float32 // deprecated
29309                         ColBox, SelBox   Box
29310                         Pointable        bool
29311                         Visual           string
29312                         VisualSize       [3]float32
29313                         Textures         []Texture
29314                         SpriteSheetSize  [2]int16 // in sprites.
29315                         SpritePos        [2]int16 // in sprite sheet.
29316                         Visible          bool
29317                         MakeFootstepSnds bool
29318                         RotateSpeed      float32 // in radians per second.
29319                         Mesh             string
29320                         Colors           []color.NRGBA
29321                         CollideWithAOs   bool
29322                         StepHeight       float32
29323                         FaceRotateDir    bool
29324                         FaceRotateDirOff float32 // in degrees.
29325                         BackfaceCull     bool
29326                         Nametag          string
29327                         NametagColor     color.NRGBA
29328                         FaceRotateSpeed  float32 // in degrees per second.
29329                         Infotext         string
29330                         Itemstring       string
29331                         Glow             int8
29332                         MaxBreath        uint16  // Player only.
29333                         EyeHeight        float32 // Player only.
29334                         ZoomFOV          float32 // in degrees. Player only.
29335                         UseTextureAlpha  bool
29336                         DmgTextureMod    Texture // suffix
29337                         Shaded           bool
29338                         ShowOnMinimap    bool
29339                         NametagBG        color.NRGBA
29340                 }))(obj)).DmgTextureMod).serialize(w)
29341         }); err != nil {
29342                 if err == io.EOF {
29343                         chk(io.EOF)
29344                 }
29345                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
29346         }
29347         {
29348                 x := (*(*(struct {
29349                         MaxHP            uint16 // Player only.
29350                         CollideWithNodes bool
29351                         Weight           float32 // deprecated
29352                         ColBox, SelBox   Box
29353                         Pointable        bool
29354                         Visual           string
29355                         VisualSize       [3]float32
29356                         Textures         []Texture
29357                         SpriteSheetSize  [2]int16 // in sprites.
29358                         SpritePos        [2]int16 // in sprite sheet.
29359                         Visible          bool
29360                         MakeFootstepSnds bool
29361                         RotateSpeed      float32 // in radians per second.
29362                         Mesh             string
29363                         Colors           []color.NRGBA
29364                         CollideWithAOs   bool
29365                         StepHeight       float32
29366                         FaceRotateDir    bool
29367                         FaceRotateDirOff float32 // in degrees.
29368                         BackfaceCull     bool
29369                         Nametag          string
29370                         NametagColor     color.NRGBA
29371                         FaceRotateSpeed  float32 // in degrees per second.
29372                         Infotext         string
29373                         Itemstring       string
29374                         Glow             int8
29375                         MaxBreath        uint16  // Player only.
29376                         EyeHeight        float32 // Player only.
29377                         ZoomFOV          float32 // in degrees. Player only.
29378                         UseTextureAlpha  bool
29379                         DmgTextureMod    Texture // suffix
29380                         Shaded           bool
29381                         ShowOnMinimap    bool
29382                         NametagBG        color.NRGBA
29383                 }))(obj)).Shaded
29384                 if x {
29385                         write8(w, 1)
29386                 } else {
29387                         write8(w, 0)
29388                 }
29389         }
29390         {
29391                 x := (*(*(struct {
29392                         MaxHP            uint16 // Player only.
29393                         CollideWithNodes bool
29394                         Weight           float32 // deprecated
29395                         ColBox, SelBox   Box
29396                         Pointable        bool
29397                         Visual           string
29398                         VisualSize       [3]float32
29399                         Textures         []Texture
29400                         SpriteSheetSize  [2]int16 // in sprites.
29401                         SpritePos        [2]int16 // in sprite sheet.
29402                         Visible          bool
29403                         MakeFootstepSnds bool
29404                         RotateSpeed      float32 // in radians per second.
29405                         Mesh             string
29406                         Colors           []color.NRGBA
29407                         CollideWithAOs   bool
29408                         StepHeight       float32
29409                         FaceRotateDir    bool
29410                         FaceRotateDirOff float32 // in degrees.
29411                         BackfaceCull     bool
29412                         Nametag          string
29413                         NametagColor     color.NRGBA
29414                         FaceRotateSpeed  float32 // in degrees per second.
29415                         Infotext         string
29416                         Itemstring       string
29417                         Glow             int8
29418                         MaxBreath        uint16  // Player only.
29419                         EyeHeight        float32 // Player only.
29420                         ZoomFOV          float32 // in degrees. Player only.
29421                         UseTextureAlpha  bool
29422                         DmgTextureMod    Texture // suffix
29423                         Shaded           bool
29424                         ShowOnMinimap    bool
29425                         NametagBG        color.NRGBA
29426                 }))(obj)).ShowOnMinimap
29427                 if x {
29428                         write8(w, 1)
29429                 } else {
29430                         write8(w, 0)
29431                 }
29432         }
29433         {
29434                 x := (*(*(struct {
29435                         MaxHP            uint16 // Player only.
29436                         CollideWithNodes bool
29437                         Weight           float32 // deprecated
29438                         ColBox, SelBox   Box
29439                         Pointable        bool
29440                         Visual           string
29441                         VisualSize       [3]float32
29442                         Textures         []Texture
29443                         SpriteSheetSize  [2]int16 // in sprites.
29444                         SpritePos        [2]int16 // in sprite sheet.
29445                         Visible          bool
29446                         MakeFootstepSnds bool
29447                         RotateSpeed      float32 // in radians per second.
29448                         Mesh             string
29449                         Colors           []color.NRGBA
29450                         CollideWithAOs   bool
29451                         StepHeight       float32
29452                         FaceRotateDir    bool
29453                         FaceRotateDirOff float32 // in degrees.
29454                         BackfaceCull     bool
29455                         Nametag          string
29456                         NametagColor     color.NRGBA
29457                         FaceRotateSpeed  float32 // in degrees per second.
29458                         Infotext         string
29459                         Itemstring       string
29460                         Glow             int8
29461                         MaxBreath        uint16  // Player only.
29462                         EyeHeight        float32 // Player only.
29463                         ZoomFOV          float32 // in degrees. Player only.
29464                         UseTextureAlpha  bool
29465                         DmgTextureMod    Texture // suffix
29466                         Shaded           bool
29467                         ShowOnMinimap    bool
29468                         NametagBG        color.NRGBA
29469                 }))(obj)).NametagBG
29470                 w.Write([]byte{x.A, x.R, x.G, x.B})
29471         }
29472 }
29473
29474 func (obj *AOProps) deserialize(r io.Reader) {
29475         {
29476                 var local339 uint8
29477                 local340 := uint8(4)
29478                 {
29479                         p := &local339
29480                         *p = read8(r)
29481                 }
29482                 if local339 != local340 {
29483                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local339))
29484                 }
29485         }
29486         {
29487                 p := &(*(*(struct {
29488                         MaxHP            uint16 // Player only.
29489                         CollideWithNodes bool
29490                         Weight           float32 // deprecated
29491                         ColBox, SelBox   Box
29492                         Pointable        bool
29493                         Visual           string
29494                         VisualSize       [3]float32
29495                         Textures         []Texture
29496                         SpriteSheetSize  [2]int16 // in sprites.
29497                         SpritePos        [2]int16 // in sprite sheet.
29498                         Visible          bool
29499                         MakeFootstepSnds bool
29500                         RotateSpeed      float32 // in radians per second.
29501                         Mesh             string
29502                         Colors           []color.NRGBA
29503                         CollideWithAOs   bool
29504                         StepHeight       float32
29505                         FaceRotateDir    bool
29506                         FaceRotateDirOff float32 // in degrees.
29507                         BackfaceCull     bool
29508                         Nametag          string
29509                         NametagColor     color.NRGBA
29510                         FaceRotateSpeed  float32 // in degrees per second.
29511                         Infotext         string
29512                         Itemstring       string
29513                         Glow             int8
29514                         MaxBreath        uint16  // Player only.
29515                         EyeHeight        float32 // Player only.
29516                         ZoomFOV          float32 // in degrees. Player only.
29517                         UseTextureAlpha  bool
29518                         DmgTextureMod    Texture // suffix
29519                         Shaded           bool
29520                         ShowOnMinimap    bool
29521                         NametagBG        color.NRGBA
29522                 }))(obj)).MaxHP
29523                 *p = read16(r)
29524         }
29525         {
29526                 p := &(*(*(struct {
29527                         MaxHP            uint16 // Player only.
29528                         CollideWithNodes bool
29529                         Weight           float32 // deprecated
29530                         ColBox, SelBox   Box
29531                         Pointable        bool
29532                         Visual           string
29533                         VisualSize       [3]float32
29534                         Textures         []Texture
29535                         SpriteSheetSize  [2]int16 // in sprites.
29536                         SpritePos        [2]int16 // in sprite sheet.
29537                         Visible          bool
29538                         MakeFootstepSnds bool
29539                         RotateSpeed      float32 // in radians per second.
29540                         Mesh             string
29541                         Colors           []color.NRGBA
29542                         CollideWithAOs   bool
29543                         StepHeight       float32
29544                         FaceRotateDir    bool
29545                         FaceRotateDirOff float32 // in degrees.
29546                         BackfaceCull     bool
29547                         Nametag          string
29548                         NametagColor     color.NRGBA
29549                         FaceRotateSpeed  float32 // in degrees per second.
29550                         Infotext         string
29551                         Itemstring       string
29552                         Glow             int8
29553                         MaxBreath        uint16  // Player only.
29554                         EyeHeight        float32 // Player only.
29555                         ZoomFOV          float32 // in degrees. Player only.
29556                         UseTextureAlpha  bool
29557                         DmgTextureMod    Texture // suffix
29558                         Shaded           bool
29559                         ShowOnMinimap    bool
29560                         NametagBG        color.NRGBA
29561                 }))(obj)).CollideWithNodes
29562                 switch n := read8(r); n {
29563                 case 0:
29564                         *p = false
29565                 case 1:
29566                         *p = true
29567                 default:
29568                         chk(fmt.Errorf("invalid bool: %d", n))
29569                 }
29570         }
29571         {
29572                 p := &(*(*(struct {
29573                         MaxHP            uint16 // Player only.
29574                         CollideWithNodes bool
29575                         Weight           float32 // deprecated
29576                         ColBox, SelBox   Box
29577                         Pointable        bool
29578                         Visual           string
29579                         VisualSize       [3]float32
29580                         Textures         []Texture
29581                         SpriteSheetSize  [2]int16 // in sprites.
29582                         SpritePos        [2]int16 // in sprite sheet.
29583                         Visible          bool
29584                         MakeFootstepSnds bool
29585                         RotateSpeed      float32 // in radians per second.
29586                         Mesh             string
29587                         Colors           []color.NRGBA
29588                         CollideWithAOs   bool
29589                         StepHeight       float32
29590                         FaceRotateDir    bool
29591                         FaceRotateDirOff float32 // in degrees.
29592                         BackfaceCull     bool
29593                         Nametag          string
29594                         NametagColor     color.NRGBA
29595                         FaceRotateSpeed  float32 // in degrees per second.
29596                         Infotext         string
29597                         Itemstring       string
29598                         Glow             int8
29599                         MaxBreath        uint16  // Player only.
29600                         EyeHeight        float32 // Player only.
29601                         ZoomFOV          float32 // in degrees. Player only.
29602                         UseTextureAlpha  bool
29603                         DmgTextureMod    Texture // suffix
29604                         Shaded           bool
29605                         ShowOnMinimap    bool
29606                         NametagBG        color.NRGBA
29607                 }))(obj)).Weight
29608                 *p = math.Float32frombits(read32(r))
29609         }
29610         if err := pcall(func() {
29611                 ((*(*(struct {
29612                         MaxHP            uint16 // Player only.
29613                         CollideWithNodes bool
29614                         Weight           float32 // deprecated
29615                         ColBox, SelBox   Box
29616                         Pointable        bool
29617                         Visual           string
29618                         VisualSize       [3]float32
29619                         Textures         []Texture
29620                         SpriteSheetSize  [2]int16 // in sprites.
29621                         SpritePos        [2]int16 // in sprite sheet.
29622                         Visible          bool
29623                         MakeFootstepSnds bool
29624                         RotateSpeed      float32 // in radians per second.
29625                         Mesh             string
29626                         Colors           []color.NRGBA
29627                         CollideWithAOs   bool
29628                         StepHeight       float32
29629                         FaceRotateDir    bool
29630                         FaceRotateDirOff float32 // in degrees.
29631                         BackfaceCull     bool
29632                         Nametag          string
29633                         NametagColor     color.NRGBA
29634                         FaceRotateSpeed  float32 // in degrees per second.
29635                         Infotext         string
29636                         Itemstring       string
29637                         Glow             int8
29638                         MaxBreath        uint16  // Player only.
29639                         EyeHeight        float32 // Player only.
29640                         ZoomFOV          float32 // in degrees. Player only.
29641                         UseTextureAlpha  bool
29642                         DmgTextureMod    Texture // suffix
29643                         Shaded           bool
29644                         ShowOnMinimap    bool
29645                         NametagBG        color.NRGBA
29646                 }))(obj)).ColBox).deserialize(r)
29647         }); err != nil {
29648                 if err == io.EOF {
29649                         chk(io.EOF)
29650                 }
29651                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
29652         }
29653         if err := pcall(func() {
29654                 ((*(*(struct {
29655                         MaxHP            uint16 // Player only.
29656                         CollideWithNodes bool
29657                         Weight           float32 // deprecated
29658                         ColBox, SelBox   Box
29659                         Pointable        bool
29660                         Visual           string
29661                         VisualSize       [3]float32
29662                         Textures         []Texture
29663                         SpriteSheetSize  [2]int16 // in sprites.
29664                         SpritePos        [2]int16 // in sprite sheet.
29665                         Visible          bool
29666                         MakeFootstepSnds bool
29667                         RotateSpeed      float32 // in radians per second.
29668                         Mesh             string
29669                         Colors           []color.NRGBA
29670                         CollideWithAOs   bool
29671                         StepHeight       float32
29672                         FaceRotateDir    bool
29673                         FaceRotateDirOff float32 // in degrees.
29674                         BackfaceCull     bool
29675                         Nametag          string
29676                         NametagColor     color.NRGBA
29677                         FaceRotateSpeed  float32 // in degrees per second.
29678                         Infotext         string
29679                         Itemstring       string
29680                         Glow             int8
29681                         MaxBreath        uint16  // Player only.
29682                         EyeHeight        float32 // Player only.
29683                         ZoomFOV          float32 // in degrees. Player only.
29684                         UseTextureAlpha  bool
29685                         DmgTextureMod    Texture // suffix
29686                         Shaded           bool
29687                         ShowOnMinimap    bool
29688                         NametagBG        color.NRGBA
29689                 }))(obj)).SelBox).deserialize(r)
29690         }); err != nil {
29691                 if err == io.EOF {
29692                         chk(io.EOF)
29693                 }
29694                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
29695         }
29696         {
29697                 p := &(*(*(struct {
29698                         MaxHP            uint16 // Player only.
29699                         CollideWithNodes bool
29700                         Weight           float32 // deprecated
29701                         ColBox, SelBox   Box
29702                         Pointable        bool
29703                         Visual           string
29704                         VisualSize       [3]float32
29705                         Textures         []Texture
29706                         SpriteSheetSize  [2]int16 // in sprites.
29707                         SpritePos        [2]int16 // in sprite sheet.
29708                         Visible          bool
29709                         MakeFootstepSnds bool
29710                         RotateSpeed      float32 // in radians per second.
29711                         Mesh             string
29712                         Colors           []color.NRGBA
29713                         CollideWithAOs   bool
29714                         StepHeight       float32
29715                         FaceRotateDir    bool
29716                         FaceRotateDirOff float32 // in degrees.
29717                         BackfaceCull     bool
29718                         Nametag          string
29719                         NametagColor     color.NRGBA
29720                         FaceRotateSpeed  float32 // in degrees per second.
29721                         Infotext         string
29722                         Itemstring       string
29723                         Glow             int8
29724                         MaxBreath        uint16  // Player only.
29725                         EyeHeight        float32 // Player only.
29726                         ZoomFOV          float32 // in degrees. Player only.
29727                         UseTextureAlpha  bool
29728                         DmgTextureMod    Texture // suffix
29729                         Shaded           bool
29730                         ShowOnMinimap    bool
29731                         NametagBG        color.NRGBA
29732                 }))(obj)).Pointable
29733                 switch n := read8(r); n {
29734                 case 0:
29735                         *p = false
29736                 case 1:
29737                         *p = true
29738                 default:
29739                         chk(fmt.Errorf("invalid bool: %d", n))
29740                 }
29741         }
29742         var local341 []uint8
29743         var local342 uint16
29744         {
29745                 p := &local342
29746                 *p = read16(r)
29747         }
29748         (local341) = make([]uint8, local342)
29749         {
29750                 _, err := io.ReadFull(r, (local341)[:])
29751                 chk(err)
29752         }
29753         ((*(*(struct {
29754                 MaxHP            uint16 // Player only.
29755                 CollideWithNodes bool
29756                 Weight           float32 // deprecated
29757                 ColBox, SelBox   Box
29758                 Pointable        bool
29759                 Visual           string
29760                 VisualSize       [3]float32
29761                 Textures         []Texture
29762                 SpriteSheetSize  [2]int16 // in sprites.
29763                 SpritePos        [2]int16 // in sprite sheet.
29764                 Visible          bool
29765                 MakeFootstepSnds bool
29766                 RotateSpeed      float32 // in radians per second.
29767                 Mesh             string
29768                 Colors           []color.NRGBA
29769                 CollideWithAOs   bool
29770                 StepHeight       float32
29771                 FaceRotateDir    bool
29772                 FaceRotateDirOff float32 // in degrees.
29773                 BackfaceCull     bool
29774                 Nametag          string
29775                 NametagColor     color.NRGBA
29776                 FaceRotateSpeed  float32 // in degrees per second.
29777                 Infotext         string
29778                 Itemstring       string
29779                 Glow             int8
29780                 MaxBreath        uint16  // Player only.
29781                 EyeHeight        float32 // Player only.
29782                 ZoomFOV          float32 // in degrees. Player only.
29783                 UseTextureAlpha  bool
29784                 DmgTextureMod    Texture // suffix
29785                 Shaded           bool
29786                 ShowOnMinimap    bool
29787                 NametagBG        color.NRGBA
29788         }))(obj)).Visual) = string(local341)
29789         for local343 := range (*(*(struct {
29790                 MaxHP            uint16 // Player only.
29791                 CollideWithNodes bool
29792                 Weight           float32 // deprecated
29793                 ColBox, SelBox   Box
29794                 Pointable        bool
29795                 Visual           string
29796                 VisualSize       [3]float32
29797                 Textures         []Texture
29798                 SpriteSheetSize  [2]int16 // in sprites.
29799                 SpritePos        [2]int16 // in sprite sheet.
29800                 Visible          bool
29801                 MakeFootstepSnds bool
29802                 RotateSpeed      float32 // in radians per second.
29803                 Mesh             string
29804                 Colors           []color.NRGBA
29805                 CollideWithAOs   bool
29806                 StepHeight       float32
29807                 FaceRotateDir    bool
29808                 FaceRotateDirOff float32 // in degrees.
29809                 BackfaceCull     bool
29810                 Nametag          string
29811                 NametagColor     color.NRGBA
29812                 FaceRotateSpeed  float32 // in degrees per second.
29813                 Infotext         string
29814                 Itemstring       string
29815                 Glow             int8
29816                 MaxBreath        uint16  // Player only.
29817                 EyeHeight        float32 // Player only.
29818                 ZoomFOV          float32 // in degrees. Player only.
29819                 UseTextureAlpha  bool
29820                 DmgTextureMod    Texture // suffix
29821                 Shaded           bool
29822                 ShowOnMinimap    bool
29823                 NametagBG        color.NRGBA
29824         }))(obj)).VisualSize {
29825                 {
29826                         p := &((*(*(struct {
29827                                 MaxHP            uint16 // Player only.
29828                                 CollideWithNodes bool
29829                                 Weight           float32 // deprecated
29830                                 ColBox, SelBox   Box
29831                                 Pointable        bool
29832                                 Visual           string
29833                                 VisualSize       [3]float32
29834                                 Textures         []Texture
29835                                 SpriteSheetSize  [2]int16 // in sprites.
29836                                 SpritePos        [2]int16 // in sprite sheet.
29837                                 Visible          bool
29838                                 MakeFootstepSnds bool
29839                                 RotateSpeed      float32 // in radians per second.
29840                                 Mesh             string
29841                                 Colors           []color.NRGBA
29842                                 CollideWithAOs   bool
29843                                 StepHeight       float32
29844                                 FaceRotateDir    bool
29845                                 FaceRotateDirOff float32 // in degrees.
29846                                 BackfaceCull     bool
29847                                 Nametag          string
29848                                 NametagColor     color.NRGBA
29849                                 FaceRotateSpeed  float32 // in degrees per second.
29850                                 Infotext         string
29851                                 Itemstring       string
29852                                 Glow             int8
29853                                 MaxBreath        uint16  // Player only.
29854                                 EyeHeight        float32 // Player only.
29855                                 ZoomFOV          float32 // in degrees. Player only.
29856                                 UseTextureAlpha  bool
29857                                 DmgTextureMod    Texture // suffix
29858                                 Shaded           bool
29859                                 ShowOnMinimap    bool
29860                                 NametagBG        color.NRGBA
29861                         }))(obj)).VisualSize)[local343]
29862                         *p = math.Float32frombits(read32(r))
29863                 }
29864         }
29865         var local344 uint16
29866         {
29867                 p := &local344
29868                 *p = read16(r)
29869         }
29870         ((*(*(struct {
29871                 MaxHP            uint16 // Player only.
29872                 CollideWithNodes bool
29873                 Weight           float32 // deprecated
29874                 ColBox, SelBox   Box
29875                 Pointable        bool
29876                 Visual           string
29877                 VisualSize       [3]float32
29878                 Textures         []Texture
29879                 SpriteSheetSize  [2]int16 // in sprites.
29880                 SpritePos        [2]int16 // in sprite sheet.
29881                 Visible          bool
29882                 MakeFootstepSnds bool
29883                 RotateSpeed      float32 // in radians per second.
29884                 Mesh             string
29885                 Colors           []color.NRGBA
29886                 CollideWithAOs   bool
29887                 StepHeight       float32
29888                 FaceRotateDir    bool
29889                 FaceRotateDirOff float32 // in degrees.
29890                 BackfaceCull     bool
29891                 Nametag          string
29892                 NametagColor     color.NRGBA
29893                 FaceRotateSpeed  float32 // in degrees per second.
29894                 Infotext         string
29895                 Itemstring       string
29896                 Glow             int8
29897                 MaxBreath        uint16  // Player only.
29898                 EyeHeight        float32 // Player only.
29899                 ZoomFOV          float32 // in degrees. Player only.
29900                 UseTextureAlpha  bool
29901                 DmgTextureMod    Texture // suffix
29902                 Shaded           bool
29903                 ShowOnMinimap    bool
29904                 NametagBG        color.NRGBA
29905         }))(obj)).Textures) = make([]Texture, local344)
29906         for local345 := range (*(*(struct {
29907                 MaxHP            uint16 // Player only.
29908                 CollideWithNodes bool
29909                 Weight           float32 // deprecated
29910                 ColBox, SelBox   Box
29911                 Pointable        bool
29912                 Visual           string
29913                 VisualSize       [3]float32
29914                 Textures         []Texture
29915                 SpriteSheetSize  [2]int16 // in sprites.
29916                 SpritePos        [2]int16 // in sprite sheet.
29917                 Visible          bool
29918                 MakeFootstepSnds bool
29919                 RotateSpeed      float32 // in radians per second.
29920                 Mesh             string
29921                 Colors           []color.NRGBA
29922                 CollideWithAOs   bool
29923                 StepHeight       float32
29924                 FaceRotateDir    bool
29925                 FaceRotateDirOff float32 // in degrees.
29926                 BackfaceCull     bool
29927                 Nametag          string
29928                 NametagColor     color.NRGBA
29929                 FaceRotateSpeed  float32 // in degrees per second.
29930                 Infotext         string
29931                 Itemstring       string
29932                 Glow             int8
29933                 MaxBreath        uint16  // Player only.
29934                 EyeHeight        float32 // Player only.
29935                 ZoomFOV          float32 // in degrees. Player only.
29936                 UseTextureAlpha  bool
29937                 DmgTextureMod    Texture // suffix
29938                 Shaded           bool
29939                 ShowOnMinimap    bool
29940                 NametagBG        color.NRGBA
29941         }))(obj)).Textures {
29942                 if err := pcall(func() {
29943                         (((*(*(struct {
29944                                 MaxHP            uint16 // Player only.
29945                                 CollideWithNodes bool
29946                                 Weight           float32 // deprecated
29947                                 ColBox, SelBox   Box
29948                                 Pointable        bool
29949                                 Visual           string
29950                                 VisualSize       [3]float32
29951                                 Textures         []Texture
29952                                 SpriteSheetSize  [2]int16 // in sprites.
29953                                 SpritePos        [2]int16 // in sprite sheet.
29954                                 Visible          bool
29955                                 MakeFootstepSnds bool
29956                                 RotateSpeed      float32 // in radians per second.
29957                                 Mesh             string
29958                                 Colors           []color.NRGBA
29959                                 CollideWithAOs   bool
29960                                 StepHeight       float32
29961                                 FaceRotateDir    bool
29962                                 FaceRotateDirOff float32 // in degrees.
29963                                 BackfaceCull     bool
29964                                 Nametag          string
29965                                 NametagColor     color.NRGBA
29966                                 FaceRotateSpeed  float32 // in degrees per second.
29967                                 Infotext         string
29968                                 Itemstring       string
29969                                 Glow             int8
29970                                 MaxBreath        uint16  // Player only.
29971                                 EyeHeight        float32 // Player only.
29972                                 ZoomFOV          float32 // in degrees. Player only.
29973                                 UseTextureAlpha  bool
29974                                 DmgTextureMod    Texture // suffix
29975                                 Shaded           bool
29976                                 ShowOnMinimap    bool
29977                                 NametagBG        color.NRGBA
29978                         }))(obj)).Textures)[local345]).deserialize(r)
29979                 }); err != nil {
29980                         if err == io.EOF {
29981                                 chk(io.EOF)
29982                         }
29983                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
29984                 }
29985         }
29986         for local346 := range (*(*(struct {
29987                 MaxHP            uint16 // Player only.
29988                 CollideWithNodes bool
29989                 Weight           float32 // deprecated
29990                 ColBox, SelBox   Box
29991                 Pointable        bool
29992                 Visual           string
29993                 VisualSize       [3]float32
29994                 Textures         []Texture
29995                 SpriteSheetSize  [2]int16 // in sprites.
29996                 SpritePos        [2]int16 // in sprite sheet.
29997                 Visible          bool
29998                 MakeFootstepSnds bool
29999                 RotateSpeed      float32 // in radians per second.
30000                 Mesh             string
30001                 Colors           []color.NRGBA
30002                 CollideWithAOs   bool
30003                 StepHeight       float32
30004                 FaceRotateDir    bool
30005                 FaceRotateDirOff float32 // in degrees.
30006                 BackfaceCull     bool
30007                 Nametag          string
30008                 NametagColor     color.NRGBA
30009                 FaceRotateSpeed  float32 // in degrees per second.
30010                 Infotext         string
30011                 Itemstring       string
30012                 Glow             int8
30013                 MaxBreath        uint16  // Player only.
30014                 EyeHeight        float32 // Player only.
30015                 ZoomFOV          float32 // in degrees. Player only.
30016                 UseTextureAlpha  bool
30017                 DmgTextureMod    Texture // suffix
30018                 Shaded           bool
30019                 ShowOnMinimap    bool
30020                 NametagBG        color.NRGBA
30021         }))(obj)).SpriteSheetSize {
30022                 {
30023                         p := &((*(*(struct {
30024                                 MaxHP            uint16 // Player only.
30025                                 CollideWithNodes bool
30026                                 Weight           float32 // deprecated
30027                                 ColBox, SelBox   Box
30028                                 Pointable        bool
30029                                 Visual           string
30030                                 VisualSize       [3]float32
30031                                 Textures         []Texture
30032                                 SpriteSheetSize  [2]int16 // in sprites.
30033                                 SpritePos        [2]int16 // in sprite sheet.
30034                                 Visible          bool
30035                                 MakeFootstepSnds bool
30036                                 RotateSpeed      float32 // in radians per second.
30037                                 Mesh             string
30038                                 Colors           []color.NRGBA
30039                                 CollideWithAOs   bool
30040                                 StepHeight       float32
30041                                 FaceRotateDir    bool
30042                                 FaceRotateDirOff float32 // in degrees.
30043                                 BackfaceCull     bool
30044                                 Nametag          string
30045                                 NametagColor     color.NRGBA
30046                                 FaceRotateSpeed  float32 // in degrees per second.
30047                                 Infotext         string
30048                                 Itemstring       string
30049                                 Glow             int8
30050                                 MaxBreath        uint16  // Player only.
30051                                 EyeHeight        float32 // Player only.
30052                                 ZoomFOV          float32 // in degrees. Player only.
30053                                 UseTextureAlpha  bool
30054                                 DmgTextureMod    Texture // suffix
30055                                 Shaded           bool
30056                                 ShowOnMinimap    bool
30057                                 NametagBG        color.NRGBA
30058                         }))(obj)).SpriteSheetSize)[local346]
30059                         *p = int16(read16(r))
30060                 }
30061         }
30062         for local347 := range (*(*(struct {
30063                 MaxHP            uint16 // Player only.
30064                 CollideWithNodes bool
30065                 Weight           float32 // deprecated
30066                 ColBox, SelBox   Box
30067                 Pointable        bool
30068                 Visual           string
30069                 VisualSize       [3]float32
30070                 Textures         []Texture
30071                 SpriteSheetSize  [2]int16 // in sprites.
30072                 SpritePos        [2]int16 // in sprite sheet.
30073                 Visible          bool
30074                 MakeFootstepSnds bool
30075                 RotateSpeed      float32 // in radians per second.
30076                 Mesh             string
30077                 Colors           []color.NRGBA
30078                 CollideWithAOs   bool
30079                 StepHeight       float32
30080                 FaceRotateDir    bool
30081                 FaceRotateDirOff float32 // in degrees.
30082                 BackfaceCull     bool
30083                 Nametag          string
30084                 NametagColor     color.NRGBA
30085                 FaceRotateSpeed  float32 // in degrees per second.
30086                 Infotext         string
30087                 Itemstring       string
30088                 Glow             int8
30089                 MaxBreath        uint16  // Player only.
30090                 EyeHeight        float32 // Player only.
30091                 ZoomFOV          float32 // in degrees. Player only.
30092                 UseTextureAlpha  bool
30093                 DmgTextureMod    Texture // suffix
30094                 Shaded           bool
30095                 ShowOnMinimap    bool
30096                 NametagBG        color.NRGBA
30097         }))(obj)).SpritePos {
30098                 {
30099                         p := &((*(*(struct {
30100                                 MaxHP            uint16 // Player only.
30101                                 CollideWithNodes bool
30102                                 Weight           float32 // deprecated
30103                                 ColBox, SelBox   Box
30104                                 Pointable        bool
30105                                 Visual           string
30106                                 VisualSize       [3]float32
30107                                 Textures         []Texture
30108                                 SpriteSheetSize  [2]int16 // in sprites.
30109                                 SpritePos        [2]int16 // in sprite sheet.
30110                                 Visible          bool
30111                                 MakeFootstepSnds bool
30112                                 RotateSpeed      float32 // in radians per second.
30113                                 Mesh             string
30114                                 Colors           []color.NRGBA
30115                                 CollideWithAOs   bool
30116                                 StepHeight       float32
30117                                 FaceRotateDir    bool
30118                                 FaceRotateDirOff float32 // in degrees.
30119                                 BackfaceCull     bool
30120                                 Nametag          string
30121                                 NametagColor     color.NRGBA
30122                                 FaceRotateSpeed  float32 // in degrees per second.
30123                                 Infotext         string
30124                                 Itemstring       string
30125                                 Glow             int8
30126                                 MaxBreath        uint16  // Player only.
30127                                 EyeHeight        float32 // Player only.
30128                                 ZoomFOV          float32 // in degrees. Player only.
30129                                 UseTextureAlpha  bool
30130                                 DmgTextureMod    Texture // suffix
30131                                 Shaded           bool
30132                                 ShowOnMinimap    bool
30133                                 NametagBG        color.NRGBA
30134                         }))(obj)).SpritePos)[local347]
30135                         *p = int16(read16(r))
30136                 }
30137         }
30138         {
30139                 p := &(*(*(struct {
30140                         MaxHP            uint16 // Player only.
30141                         CollideWithNodes bool
30142                         Weight           float32 // deprecated
30143                         ColBox, SelBox   Box
30144                         Pointable        bool
30145                         Visual           string
30146                         VisualSize       [3]float32
30147                         Textures         []Texture
30148                         SpriteSheetSize  [2]int16 // in sprites.
30149                         SpritePos        [2]int16 // in sprite sheet.
30150                         Visible          bool
30151                         MakeFootstepSnds bool
30152                         RotateSpeed      float32 // in radians per second.
30153                         Mesh             string
30154                         Colors           []color.NRGBA
30155                         CollideWithAOs   bool
30156                         StepHeight       float32
30157                         FaceRotateDir    bool
30158                         FaceRotateDirOff float32 // in degrees.
30159                         BackfaceCull     bool
30160                         Nametag          string
30161                         NametagColor     color.NRGBA
30162                         FaceRotateSpeed  float32 // in degrees per second.
30163                         Infotext         string
30164                         Itemstring       string
30165                         Glow             int8
30166                         MaxBreath        uint16  // Player only.
30167                         EyeHeight        float32 // Player only.
30168                         ZoomFOV          float32 // in degrees. Player only.
30169                         UseTextureAlpha  bool
30170                         DmgTextureMod    Texture // suffix
30171                         Shaded           bool
30172                         ShowOnMinimap    bool
30173                         NametagBG        color.NRGBA
30174                 }))(obj)).Visible
30175                 switch n := read8(r); n {
30176                 case 0:
30177                         *p = false
30178                 case 1:
30179                         *p = true
30180                 default:
30181                         chk(fmt.Errorf("invalid bool: %d", n))
30182                 }
30183         }
30184         {
30185                 p := &(*(*(struct {
30186                         MaxHP            uint16 // Player only.
30187                         CollideWithNodes bool
30188                         Weight           float32 // deprecated
30189                         ColBox, SelBox   Box
30190                         Pointable        bool
30191                         Visual           string
30192                         VisualSize       [3]float32
30193                         Textures         []Texture
30194                         SpriteSheetSize  [2]int16 // in sprites.
30195                         SpritePos        [2]int16 // in sprite sheet.
30196                         Visible          bool
30197                         MakeFootstepSnds bool
30198                         RotateSpeed      float32 // in radians per second.
30199                         Mesh             string
30200                         Colors           []color.NRGBA
30201                         CollideWithAOs   bool
30202                         StepHeight       float32
30203                         FaceRotateDir    bool
30204                         FaceRotateDirOff float32 // in degrees.
30205                         BackfaceCull     bool
30206                         Nametag          string
30207                         NametagColor     color.NRGBA
30208                         FaceRotateSpeed  float32 // in degrees per second.
30209                         Infotext         string
30210                         Itemstring       string
30211                         Glow             int8
30212                         MaxBreath        uint16  // Player only.
30213                         EyeHeight        float32 // Player only.
30214                         ZoomFOV          float32 // in degrees. Player only.
30215                         UseTextureAlpha  bool
30216                         DmgTextureMod    Texture // suffix
30217                         Shaded           bool
30218                         ShowOnMinimap    bool
30219                         NametagBG        color.NRGBA
30220                 }))(obj)).MakeFootstepSnds
30221                 switch n := read8(r); n {
30222                 case 0:
30223                         *p = false
30224                 case 1:
30225                         *p = true
30226                 default:
30227                         chk(fmt.Errorf("invalid bool: %d", n))
30228                 }
30229         }
30230         {
30231                 p := &(*(*(struct {
30232                         MaxHP            uint16 // Player only.
30233                         CollideWithNodes bool
30234                         Weight           float32 // deprecated
30235                         ColBox, SelBox   Box
30236                         Pointable        bool
30237                         Visual           string
30238                         VisualSize       [3]float32
30239                         Textures         []Texture
30240                         SpriteSheetSize  [2]int16 // in sprites.
30241                         SpritePos        [2]int16 // in sprite sheet.
30242                         Visible          bool
30243                         MakeFootstepSnds bool
30244                         RotateSpeed      float32 // in radians per second.
30245                         Mesh             string
30246                         Colors           []color.NRGBA
30247                         CollideWithAOs   bool
30248                         StepHeight       float32
30249                         FaceRotateDir    bool
30250                         FaceRotateDirOff float32 // in degrees.
30251                         BackfaceCull     bool
30252                         Nametag          string
30253                         NametagColor     color.NRGBA
30254                         FaceRotateSpeed  float32 // in degrees per second.
30255                         Infotext         string
30256                         Itemstring       string
30257                         Glow             int8
30258                         MaxBreath        uint16  // Player only.
30259                         EyeHeight        float32 // Player only.
30260                         ZoomFOV          float32 // in degrees. Player only.
30261                         UseTextureAlpha  bool
30262                         DmgTextureMod    Texture // suffix
30263                         Shaded           bool
30264                         ShowOnMinimap    bool
30265                         NametagBG        color.NRGBA
30266                 }))(obj)).RotateSpeed
30267                 *p = math.Float32frombits(read32(r))
30268         }
30269         var local348 []uint8
30270         var local349 uint16
30271         {
30272                 p := &local349
30273                 *p = read16(r)
30274         }
30275         (local348) = make([]uint8, local349)
30276         {
30277                 _, err := io.ReadFull(r, (local348)[:])
30278                 chk(err)
30279         }
30280         ((*(*(struct {
30281                 MaxHP            uint16 // Player only.
30282                 CollideWithNodes bool
30283                 Weight           float32 // deprecated
30284                 ColBox, SelBox   Box
30285                 Pointable        bool
30286                 Visual           string
30287                 VisualSize       [3]float32
30288                 Textures         []Texture
30289                 SpriteSheetSize  [2]int16 // in sprites.
30290                 SpritePos        [2]int16 // in sprite sheet.
30291                 Visible          bool
30292                 MakeFootstepSnds bool
30293                 RotateSpeed      float32 // in radians per second.
30294                 Mesh             string
30295                 Colors           []color.NRGBA
30296                 CollideWithAOs   bool
30297                 StepHeight       float32
30298                 FaceRotateDir    bool
30299                 FaceRotateDirOff float32 // in degrees.
30300                 BackfaceCull     bool
30301                 Nametag          string
30302                 NametagColor     color.NRGBA
30303                 FaceRotateSpeed  float32 // in degrees per second.
30304                 Infotext         string
30305                 Itemstring       string
30306                 Glow             int8
30307                 MaxBreath        uint16  // Player only.
30308                 EyeHeight        float32 // Player only.
30309                 ZoomFOV          float32 // in degrees. Player only.
30310                 UseTextureAlpha  bool
30311                 DmgTextureMod    Texture // suffix
30312                 Shaded           bool
30313                 ShowOnMinimap    bool
30314                 NametagBG        color.NRGBA
30315         }))(obj)).Mesh) = string(local348)
30316         var local350 uint16
30317         {
30318                 p := &local350
30319                 *p = read16(r)
30320         }
30321         ((*(*(struct {
30322                 MaxHP            uint16 // Player only.
30323                 CollideWithNodes bool
30324                 Weight           float32 // deprecated
30325                 ColBox, SelBox   Box
30326                 Pointable        bool
30327                 Visual           string
30328                 VisualSize       [3]float32
30329                 Textures         []Texture
30330                 SpriteSheetSize  [2]int16 // in sprites.
30331                 SpritePos        [2]int16 // in sprite sheet.
30332                 Visible          bool
30333                 MakeFootstepSnds bool
30334                 RotateSpeed      float32 // in radians per second.
30335                 Mesh             string
30336                 Colors           []color.NRGBA
30337                 CollideWithAOs   bool
30338                 StepHeight       float32
30339                 FaceRotateDir    bool
30340                 FaceRotateDirOff float32 // in degrees.
30341                 BackfaceCull     bool
30342                 Nametag          string
30343                 NametagColor     color.NRGBA
30344                 FaceRotateSpeed  float32 // in degrees per second.
30345                 Infotext         string
30346                 Itemstring       string
30347                 Glow             int8
30348                 MaxBreath        uint16  // Player only.
30349                 EyeHeight        float32 // Player only.
30350                 ZoomFOV          float32 // in degrees. Player only.
30351                 UseTextureAlpha  bool
30352                 DmgTextureMod    Texture // suffix
30353                 Shaded           bool
30354                 ShowOnMinimap    bool
30355                 NametagBG        color.NRGBA
30356         }))(obj)).Colors) = make([]color.NRGBA, local350)
30357         for local351 := range (*(*(struct {
30358                 MaxHP            uint16 // Player only.
30359                 CollideWithNodes bool
30360                 Weight           float32 // deprecated
30361                 ColBox, SelBox   Box
30362                 Pointable        bool
30363                 Visual           string
30364                 VisualSize       [3]float32
30365                 Textures         []Texture
30366                 SpriteSheetSize  [2]int16 // in sprites.
30367                 SpritePos        [2]int16 // in sprite sheet.
30368                 Visible          bool
30369                 MakeFootstepSnds bool
30370                 RotateSpeed      float32 // in radians per second.
30371                 Mesh             string
30372                 Colors           []color.NRGBA
30373                 CollideWithAOs   bool
30374                 StepHeight       float32
30375                 FaceRotateDir    bool
30376                 FaceRotateDirOff float32 // in degrees.
30377                 BackfaceCull     bool
30378                 Nametag          string
30379                 NametagColor     color.NRGBA
30380                 FaceRotateSpeed  float32 // in degrees per second.
30381                 Infotext         string
30382                 Itemstring       string
30383                 Glow             int8
30384                 MaxBreath        uint16  // Player only.
30385                 EyeHeight        float32 // Player only.
30386                 ZoomFOV          float32 // in degrees. Player only.
30387                 UseTextureAlpha  bool
30388                 DmgTextureMod    Texture // suffix
30389                 Shaded           bool
30390                 ShowOnMinimap    bool
30391                 NametagBG        color.NRGBA
30392         }))(obj)).Colors {
30393                 {
30394                         p := &((*(*(struct {
30395                                 MaxHP            uint16 // Player only.
30396                                 CollideWithNodes bool
30397                                 Weight           float32 // deprecated
30398                                 ColBox, SelBox   Box
30399                                 Pointable        bool
30400                                 Visual           string
30401                                 VisualSize       [3]float32
30402                                 Textures         []Texture
30403                                 SpriteSheetSize  [2]int16 // in sprites.
30404                                 SpritePos        [2]int16 // in sprite sheet.
30405                                 Visible          bool
30406                                 MakeFootstepSnds bool
30407                                 RotateSpeed      float32 // in radians per second.
30408                                 Mesh             string
30409                                 Colors           []color.NRGBA
30410                                 CollideWithAOs   bool
30411                                 StepHeight       float32
30412                                 FaceRotateDir    bool
30413                                 FaceRotateDirOff float32 // in degrees.
30414                                 BackfaceCull     bool
30415                                 Nametag          string
30416                                 NametagColor     color.NRGBA
30417                                 FaceRotateSpeed  float32 // in degrees per second.
30418                                 Infotext         string
30419                                 Itemstring       string
30420                                 Glow             int8
30421                                 MaxBreath        uint16  // Player only.
30422                                 EyeHeight        float32 // Player only.
30423                                 ZoomFOV          float32 // in degrees. Player only.
30424                                 UseTextureAlpha  bool
30425                                 DmgTextureMod    Texture // suffix
30426                                 Shaded           bool
30427                                 ShowOnMinimap    bool
30428                                 NametagBG        color.NRGBA
30429                         }))(obj)).Colors)[local351]
30430                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30431                 }
30432         }
30433         {
30434                 p := &(*(*(struct {
30435                         MaxHP            uint16 // Player only.
30436                         CollideWithNodes bool
30437                         Weight           float32 // deprecated
30438                         ColBox, SelBox   Box
30439                         Pointable        bool
30440                         Visual           string
30441                         VisualSize       [3]float32
30442                         Textures         []Texture
30443                         SpriteSheetSize  [2]int16 // in sprites.
30444                         SpritePos        [2]int16 // in sprite sheet.
30445                         Visible          bool
30446                         MakeFootstepSnds bool
30447                         RotateSpeed      float32 // in radians per second.
30448                         Mesh             string
30449                         Colors           []color.NRGBA
30450                         CollideWithAOs   bool
30451                         StepHeight       float32
30452                         FaceRotateDir    bool
30453                         FaceRotateDirOff float32 // in degrees.
30454                         BackfaceCull     bool
30455                         Nametag          string
30456                         NametagColor     color.NRGBA
30457                         FaceRotateSpeed  float32 // in degrees per second.
30458                         Infotext         string
30459                         Itemstring       string
30460                         Glow             int8
30461                         MaxBreath        uint16  // Player only.
30462                         EyeHeight        float32 // Player only.
30463                         ZoomFOV          float32 // in degrees. Player only.
30464                         UseTextureAlpha  bool
30465                         DmgTextureMod    Texture // suffix
30466                         Shaded           bool
30467                         ShowOnMinimap    bool
30468                         NametagBG        color.NRGBA
30469                 }))(obj)).CollideWithAOs
30470                 switch n := read8(r); n {
30471                 case 0:
30472                         *p = false
30473                 case 1:
30474                         *p = true
30475                 default:
30476                         chk(fmt.Errorf("invalid bool: %d", n))
30477                 }
30478         }
30479         {
30480                 p := &(*(*(struct {
30481                         MaxHP            uint16 // Player only.
30482                         CollideWithNodes bool
30483                         Weight           float32 // deprecated
30484                         ColBox, SelBox   Box
30485                         Pointable        bool
30486                         Visual           string
30487                         VisualSize       [3]float32
30488                         Textures         []Texture
30489                         SpriteSheetSize  [2]int16 // in sprites.
30490                         SpritePos        [2]int16 // in sprite sheet.
30491                         Visible          bool
30492                         MakeFootstepSnds bool
30493                         RotateSpeed      float32 // in radians per second.
30494                         Mesh             string
30495                         Colors           []color.NRGBA
30496                         CollideWithAOs   bool
30497                         StepHeight       float32
30498                         FaceRotateDir    bool
30499                         FaceRotateDirOff float32 // in degrees.
30500                         BackfaceCull     bool
30501                         Nametag          string
30502                         NametagColor     color.NRGBA
30503                         FaceRotateSpeed  float32 // in degrees per second.
30504                         Infotext         string
30505                         Itemstring       string
30506                         Glow             int8
30507                         MaxBreath        uint16  // Player only.
30508                         EyeHeight        float32 // Player only.
30509                         ZoomFOV          float32 // in degrees. Player only.
30510                         UseTextureAlpha  bool
30511                         DmgTextureMod    Texture // suffix
30512                         Shaded           bool
30513                         ShowOnMinimap    bool
30514                         NametagBG        color.NRGBA
30515                 }))(obj)).StepHeight
30516                 *p = math.Float32frombits(read32(r))
30517         }
30518         {
30519                 p := &(*(*(struct {
30520                         MaxHP            uint16 // Player only.
30521                         CollideWithNodes bool
30522                         Weight           float32 // deprecated
30523                         ColBox, SelBox   Box
30524                         Pointable        bool
30525                         Visual           string
30526                         VisualSize       [3]float32
30527                         Textures         []Texture
30528                         SpriteSheetSize  [2]int16 // in sprites.
30529                         SpritePos        [2]int16 // in sprite sheet.
30530                         Visible          bool
30531                         MakeFootstepSnds bool
30532                         RotateSpeed      float32 // in radians per second.
30533                         Mesh             string
30534                         Colors           []color.NRGBA
30535                         CollideWithAOs   bool
30536                         StepHeight       float32
30537                         FaceRotateDir    bool
30538                         FaceRotateDirOff float32 // in degrees.
30539                         BackfaceCull     bool
30540                         Nametag          string
30541                         NametagColor     color.NRGBA
30542                         FaceRotateSpeed  float32 // in degrees per second.
30543                         Infotext         string
30544                         Itemstring       string
30545                         Glow             int8
30546                         MaxBreath        uint16  // Player only.
30547                         EyeHeight        float32 // Player only.
30548                         ZoomFOV          float32 // in degrees. Player only.
30549                         UseTextureAlpha  bool
30550                         DmgTextureMod    Texture // suffix
30551                         Shaded           bool
30552                         ShowOnMinimap    bool
30553                         NametagBG        color.NRGBA
30554                 }))(obj)).FaceRotateDir
30555                 switch n := read8(r); n {
30556                 case 0:
30557                         *p = false
30558                 case 1:
30559                         *p = true
30560                 default:
30561                         chk(fmt.Errorf("invalid bool: %d", n))
30562                 }
30563         }
30564         {
30565                 p := &(*(*(struct {
30566                         MaxHP            uint16 // Player only.
30567                         CollideWithNodes bool
30568                         Weight           float32 // deprecated
30569                         ColBox, SelBox   Box
30570                         Pointable        bool
30571                         Visual           string
30572                         VisualSize       [3]float32
30573                         Textures         []Texture
30574                         SpriteSheetSize  [2]int16 // in sprites.
30575                         SpritePos        [2]int16 // in sprite sheet.
30576                         Visible          bool
30577                         MakeFootstepSnds bool
30578                         RotateSpeed      float32 // in radians per second.
30579                         Mesh             string
30580                         Colors           []color.NRGBA
30581                         CollideWithAOs   bool
30582                         StepHeight       float32
30583                         FaceRotateDir    bool
30584                         FaceRotateDirOff float32 // in degrees.
30585                         BackfaceCull     bool
30586                         Nametag          string
30587                         NametagColor     color.NRGBA
30588                         FaceRotateSpeed  float32 // in degrees per second.
30589                         Infotext         string
30590                         Itemstring       string
30591                         Glow             int8
30592                         MaxBreath        uint16  // Player only.
30593                         EyeHeight        float32 // Player only.
30594                         ZoomFOV          float32 // in degrees. Player only.
30595                         UseTextureAlpha  bool
30596                         DmgTextureMod    Texture // suffix
30597                         Shaded           bool
30598                         ShowOnMinimap    bool
30599                         NametagBG        color.NRGBA
30600                 }))(obj)).FaceRotateDirOff
30601                 *p = math.Float32frombits(read32(r))
30602         }
30603         {
30604                 p := &(*(*(struct {
30605                         MaxHP            uint16 // Player only.
30606                         CollideWithNodes bool
30607                         Weight           float32 // deprecated
30608                         ColBox, SelBox   Box
30609                         Pointable        bool
30610                         Visual           string
30611                         VisualSize       [3]float32
30612                         Textures         []Texture
30613                         SpriteSheetSize  [2]int16 // in sprites.
30614                         SpritePos        [2]int16 // in sprite sheet.
30615                         Visible          bool
30616                         MakeFootstepSnds bool
30617                         RotateSpeed      float32 // in radians per second.
30618                         Mesh             string
30619                         Colors           []color.NRGBA
30620                         CollideWithAOs   bool
30621                         StepHeight       float32
30622                         FaceRotateDir    bool
30623                         FaceRotateDirOff float32 // in degrees.
30624                         BackfaceCull     bool
30625                         Nametag          string
30626                         NametagColor     color.NRGBA
30627                         FaceRotateSpeed  float32 // in degrees per second.
30628                         Infotext         string
30629                         Itemstring       string
30630                         Glow             int8
30631                         MaxBreath        uint16  // Player only.
30632                         EyeHeight        float32 // Player only.
30633                         ZoomFOV          float32 // in degrees. Player only.
30634                         UseTextureAlpha  bool
30635                         DmgTextureMod    Texture // suffix
30636                         Shaded           bool
30637                         ShowOnMinimap    bool
30638                         NametagBG        color.NRGBA
30639                 }))(obj)).BackfaceCull
30640                 switch n := read8(r); n {
30641                 case 0:
30642                         *p = false
30643                 case 1:
30644                         *p = true
30645                 default:
30646                         chk(fmt.Errorf("invalid bool: %d", n))
30647                 }
30648         }
30649         var local352 []uint8
30650         var local353 uint16
30651         {
30652                 p := &local353
30653                 *p = read16(r)
30654         }
30655         (local352) = make([]uint8, local353)
30656         {
30657                 _, err := io.ReadFull(r, (local352)[:])
30658                 chk(err)
30659         }
30660         ((*(*(struct {
30661                 MaxHP            uint16 // Player only.
30662                 CollideWithNodes bool
30663                 Weight           float32 // deprecated
30664                 ColBox, SelBox   Box
30665                 Pointable        bool
30666                 Visual           string
30667                 VisualSize       [3]float32
30668                 Textures         []Texture
30669                 SpriteSheetSize  [2]int16 // in sprites.
30670                 SpritePos        [2]int16 // in sprite sheet.
30671                 Visible          bool
30672                 MakeFootstepSnds bool
30673                 RotateSpeed      float32 // in radians per second.
30674                 Mesh             string
30675                 Colors           []color.NRGBA
30676                 CollideWithAOs   bool
30677                 StepHeight       float32
30678                 FaceRotateDir    bool
30679                 FaceRotateDirOff float32 // in degrees.
30680                 BackfaceCull     bool
30681                 Nametag          string
30682                 NametagColor     color.NRGBA
30683                 FaceRotateSpeed  float32 // in degrees per second.
30684                 Infotext         string
30685                 Itemstring       string
30686                 Glow             int8
30687                 MaxBreath        uint16  // Player only.
30688                 EyeHeight        float32 // Player only.
30689                 ZoomFOV          float32 // in degrees. Player only.
30690                 UseTextureAlpha  bool
30691                 DmgTextureMod    Texture // suffix
30692                 Shaded           bool
30693                 ShowOnMinimap    bool
30694                 NametagBG        color.NRGBA
30695         }))(obj)).Nametag) = string(local352)
30696         {
30697                 p := &(*(*(struct {
30698                         MaxHP            uint16 // Player only.
30699                         CollideWithNodes bool
30700                         Weight           float32 // deprecated
30701                         ColBox, SelBox   Box
30702                         Pointable        bool
30703                         Visual           string
30704                         VisualSize       [3]float32
30705                         Textures         []Texture
30706                         SpriteSheetSize  [2]int16 // in sprites.
30707                         SpritePos        [2]int16 // in sprite sheet.
30708                         Visible          bool
30709                         MakeFootstepSnds bool
30710                         RotateSpeed      float32 // in radians per second.
30711                         Mesh             string
30712                         Colors           []color.NRGBA
30713                         CollideWithAOs   bool
30714                         StepHeight       float32
30715                         FaceRotateDir    bool
30716                         FaceRotateDirOff float32 // in degrees.
30717                         BackfaceCull     bool
30718                         Nametag          string
30719                         NametagColor     color.NRGBA
30720                         FaceRotateSpeed  float32 // in degrees per second.
30721                         Infotext         string
30722                         Itemstring       string
30723                         Glow             int8
30724                         MaxBreath        uint16  // Player only.
30725                         EyeHeight        float32 // Player only.
30726                         ZoomFOV          float32 // in degrees. Player only.
30727                         UseTextureAlpha  bool
30728                         DmgTextureMod    Texture // suffix
30729                         Shaded           bool
30730                         ShowOnMinimap    bool
30731                         NametagBG        color.NRGBA
30732                 }))(obj)).NametagColor
30733                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30734         }
30735         {
30736                 p := &(*(*(struct {
30737                         MaxHP            uint16 // Player only.
30738                         CollideWithNodes bool
30739                         Weight           float32 // deprecated
30740                         ColBox, SelBox   Box
30741                         Pointable        bool
30742                         Visual           string
30743                         VisualSize       [3]float32
30744                         Textures         []Texture
30745                         SpriteSheetSize  [2]int16 // in sprites.
30746                         SpritePos        [2]int16 // in sprite sheet.
30747                         Visible          bool
30748                         MakeFootstepSnds bool
30749                         RotateSpeed      float32 // in radians per second.
30750                         Mesh             string
30751                         Colors           []color.NRGBA
30752                         CollideWithAOs   bool
30753                         StepHeight       float32
30754                         FaceRotateDir    bool
30755                         FaceRotateDirOff float32 // in degrees.
30756                         BackfaceCull     bool
30757                         Nametag          string
30758                         NametagColor     color.NRGBA
30759                         FaceRotateSpeed  float32 // in degrees per second.
30760                         Infotext         string
30761                         Itemstring       string
30762                         Glow             int8
30763                         MaxBreath        uint16  // Player only.
30764                         EyeHeight        float32 // Player only.
30765                         ZoomFOV          float32 // in degrees. Player only.
30766                         UseTextureAlpha  bool
30767                         DmgTextureMod    Texture // suffix
30768                         Shaded           bool
30769                         ShowOnMinimap    bool
30770                         NametagBG        color.NRGBA
30771                 }))(obj)).FaceRotateSpeed
30772                 *p = math.Float32frombits(read32(r))
30773         }
30774         var local354 []uint8
30775         var local355 uint16
30776         {
30777                 p := &local355
30778                 *p = read16(r)
30779         }
30780         (local354) = make([]uint8, local355)
30781         {
30782                 _, err := io.ReadFull(r, (local354)[:])
30783                 chk(err)
30784         }
30785         ((*(*(struct {
30786                 MaxHP            uint16 // Player only.
30787                 CollideWithNodes bool
30788                 Weight           float32 // deprecated
30789                 ColBox, SelBox   Box
30790                 Pointable        bool
30791                 Visual           string
30792                 VisualSize       [3]float32
30793                 Textures         []Texture
30794                 SpriteSheetSize  [2]int16 // in sprites.
30795                 SpritePos        [2]int16 // in sprite sheet.
30796                 Visible          bool
30797                 MakeFootstepSnds bool
30798                 RotateSpeed      float32 // in radians per second.
30799                 Mesh             string
30800                 Colors           []color.NRGBA
30801                 CollideWithAOs   bool
30802                 StepHeight       float32
30803                 FaceRotateDir    bool
30804                 FaceRotateDirOff float32 // in degrees.
30805                 BackfaceCull     bool
30806                 Nametag          string
30807                 NametagColor     color.NRGBA
30808                 FaceRotateSpeed  float32 // in degrees per second.
30809                 Infotext         string
30810                 Itemstring       string
30811                 Glow             int8
30812                 MaxBreath        uint16  // Player only.
30813                 EyeHeight        float32 // Player only.
30814                 ZoomFOV          float32 // in degrees. Player only.
30815                 UseTextureAlpha  bool
30816                 DmgTextureMod    Texture // suffix
30817                 Shaded           bool
30818                 ShowOnMinimap    bool
30819                 NametagBG        color.NRGBA
30820         }))(obj)).Infotext) = string(local354)
30821         var local356 []uint8
30822         var local357 uint16
30823         {
30824                 p := &local357
30825                 *p = read16(r)
30826         }
30827         (local356) = make([]uint8, local357)
30828         {
30829                 _, err := io.ReadFull(r, (local356)[:])
30830                 chk(err)
30831         }
30832         ((*(*(struct {
30833                 MaxHP            uint16 // Player only.
30834                 CollideWithNodes bool
30835                 Weight           float32 // deprecated
30836                 ColBox, SelBox   Box
30837                 Pointable        bool
30838                 Visual           string
30839                 VisualSize       [3]float32
30840                 Textures         []Texture
30841                 SpriteSheetSize  [2]int16 // in sprites.
30842                 SpritePos        [2]int16 // in sprite sheet.
30843                 Visible          bool
30844                 MakeFootstepSnds bool
30845                 RotateSpeed      float32 // in radians per second.
30846                 Mesh             string
30847                 Colors           []color.NRGBA
30848                 CollideWithAOs   bool
30849                 StepHeight       float32
30850                 FaceRotateDir    bool
30851                 FaceRotateDirOff float32 // in degrees.
30852                 BackfaceCull     bool
30853                 Nametag          string
30854                 NametagColor     color.NRGBA
30855                 FaceRotateSpeed  float32 // in degrees per second.
30856                 Infotext         string
30857                 Itemstring       string
30858                 Glow             int8
30859                 MaxBreath        uint16  // Player only.
30860                 EyeHeight        float32 // Player only.
30861                 ZoomFOV          float32 // in degrees. Player only.
30862                 UseTextureAlpha  bool
30863                 DmgTextureMod    Texture // suffix
30864                 Shaded           bool
30865                 ShowOnMinimap    bool
30866                 NametagBG        color.NRGBA
30867         }))(obj)).Itemstring) = string(local356)
30868         {
30869                 p := &(*(*(struct {
30870                         MaxHP            uint16 // Player only.
30871                         CollideWithNodes bool
30872                         Weight           float32 // deprecated
30873                         ColBox, SelBox   Box
30874                         Pointable        bool
30875                         Visual           string
30876                         VisualSize       [3]float32
30877                         Textures         []Texture
30878                         SpriteSheetSize  [2]int16 // in sprites.
30879                         SpritePos        [2]int16 // in sprite sheet.
30880                         Visible          bool
30881                         MakeFootstepSnds bool
30882                         RotateSpeed      float32 // in radians per second.
30883                         Mesh             string
30884                         Colors           []color.NRGBA
30885                         CollideWithAOs   bool
30886                         StepHeight       float32
30887                         FaceRotateDir    bool
30888                         FaceRotateDirOff float32 // in degrees.
30889                         BackfaceCull     bool
30890                         Nametag          string
30891                         NametagColor     color.NRGBA
30892                         FaceRotateSpeed  float32 // in degrees per second.
30893                         Infotext         string
30894                         Itemstring       string
30895                         Glow             int8
30896                         MaxBreath        uint16  // Player only.
30897                         EyeHeight        float32 // Player only.
30898                         ZoomFOV          float32 // in degrees. Player only.
30899                         UseTextureAlpha  bool
30900                         DmgTextureMod    Texture // suffix
30901                         Shaded           bool
30902                         ShowOnMinimap    bool
30903                         NametagBG        color.NRGBA
30904                 }))(obj)).Glow
30905                 *p = int8(read8(r))
30906         }
30907         {
30908                 p := &(*(*(struct {
30909                         MaxHP            uint16 // Player only.
30910                         CollideWithNodes bool
30911                         Weight           float32 // deprecated
30912                         ColBox, SelBox   Box
30913                         Pointable        bool
30914                         Visual           string
30915                         VisualSize       [3]float32
30916                         Textures         []Texture
30917                         SpriteSheetSize  [2]int16 // in sprites.
30918                         SpritePos        [2]int16 // in sprite sheet.
30919                         Visible          bool
30920                         MakeFootstepSnds bool
30921                         RotateSpeed      float32 // in radians per second.
30922                         Mesh             string
30923                         Colors           []color.NRGBA
30924                         CollideWithAOs   bool
30925                         StepHeight       float32
30926                         FaceRotateDir    bool
30927                         FaceRotateDirOff float32 // in degrees.
30928                         BackfaceCull     bool
30929                         Nametag          string
30930                         NametagColor     color.NRGBA
30931                         FaceRotateSpeed  float32 // in degrees per second.
30932                         Infotext         string
30933                         Itemstring       string
30934                         Glow             int8
30935                         MaxBreath        uint16  // Player only.
30936                         EyeHeight        float32 // Player only.
30937                         ZoomFOV          float32 // in degrees. Player only.
30938                         UseTextureAlpha  bool
30939                         DmgTextureMod    Texture // suffix
30940                         Shaded           bool
30941                         ShowOnMinimap    bool
30942                         NametagBG        color.NRGBA
30943                 }))(obj)).MaxBreath
30944                 *p = read16(r)
30945         }
30946         {
30947                 p := &(*(*(struct {
30948                         MaxHP            uint16 // Player only.
30949                         CollideWithNodes bool
30950                         Weight           float32 // deprecated
30951                         ColBox, SelBox   Box
30952                         Pointable        bool
30953                         Visual           string
30954                         VisualSize       [3]float32
30955                         Textures         []Texture
30956                         SpriteSheetSize  [2]int16 // in sprites.
30957                         SpritePos        [2]int16 // in sprite sheet.
30958                         Visible          bool
30959                         MakeFootstepSnds bool
30960                         RotateSpeed      float32 // in radians per second.
30961                         Mesh             string
30962                         Colors           []color.NRGBA
30963                         CollideWithAOs   bool
30964                         StepHeight       float32
30965                         FaceRotateDir    bool
30966                         FaceRotateDirOff float32 // in degrees.
30967                         BackfaceCull     bool
30968                         Nametag          string
30969                         NametagColor     color.NRGBA
30970                         FaceRotateSpeed  float32 // in degrees per second.
30971                         Infotext         string
30972                         Itemstring       string
30973                         Glow             int8
30974                         MaxBreath        uint16  // Player only.
30975                         EyeHeight        float32 // Player only.
30976                         ZoomFOV          float32 // in degrees. Player only.
30977                         UseTextureAlpha  bool
30978                         DmgTextureMod    Texture // suffix
30979                         Shaded           bool
30980                         ShowOnMinimap    bool
30981                         NametagBG        color.NRGBA
30982                 }))(obj)).EyeHeight
30983                 *p = math.Float32frombits(read32(r))
30984         }
30985         {
30986                 p := &(*(*(struct {
30987                         MaxHP            uint16 // Player only.
30988                         CollideWithNodes bool
30989                         Weight           float32 // deprecated
30990                         ColBox, SelBox   Box
30991                         Pointable        bool
30992                         Visual           string
30993                         VisualSize       [3]float32
30994                         Textures         []Texture
30995                         SpriteSheetSize  [2]int16 // in sprites.
30996                         SpritePos        [2]int16 // in sprite sheet.
30997                         Visible          bool
30998                         MakeFootstepSnds bool
30999                         RotateSpeed      float32 // in radians per second.
31000                         Mesh             string
31001                         Colors           []color.NRGBA
31002                         CollideWithAOs   bool
31003                         StepHeight       float32
31004                         FaceRotateDir    bool
31005                         FaceRotateDirOff float32 // in degrees.
31006                         BackfaceCull     bool
31007                         Nametag          string
31008                         NametagColor     color.NRGBA
31009                         FaceRotateSpeed  float32 // in degrees per second.
31010                         Infotext         string
31011                         Itemstring       string
31012                         Glow             int8
31013                         MaxBreath        uint16  // Player only.
31014                         EyeHeight        float32 // Player only.
31015                         ZoomFOV          float32 // in degrees. Player only.
31016                         UseTextureAlpha  bool
31017                         DmgTextureMod    Texture // suffix
31018                         Shaded           bool
31019                         ShowOnMinimap    bool
31020                         NametagBG        color.NRGBA
31021                 }))(obj)).ZoomFOV
31022                 *p = math.Float32frombits(read32(r))
31023         }
31024         {
31025                 p := &(*(*(struct {
31026                         MaxHP            uint16 // Player only.
31027                         CollideWithNodes bool
31028                         Weight           float32 // deprecated
31029                         ColBox, SelBox   Box
31030                         Pointable        bool
31031                         Visual           string
31032                         VisualSize       [3]float32
31033                         Textures         []Texture
31034                         SpriteSheetSize  [2]int16 // in sprites.
31035                         SpritePos        [2]int16 // in sprite sheet.
31036                         Visible          bool
31037                         MakeFootstepSnds bool
31038                         RotateSpeed      float32 // in radians per second.
31039                         Mesh             string
31040                         Colors           []color.NRGBA
31041                         CollideWithAOs   bool
31042                         StepHeight       float32
31043                         FaceRotateDir    bool
31044                         FaceRotateDirOff float32 // in degrees.
31045                         BackfaceCull     bool
31046                         Nametag          string
31047                         NametagColor     color.NRGBA
31048                         FaceRotateSpeed  float32 // in degrees per second.
31049                         Infotext         string
31050                         Itemstring       string
31051                         Glow             int8
31052                         MaxBreath        uint16  // Player only.
31053                         EyeHeight        float32 // Player only.
31054                         ZoomFOV          float32 // in degrees. Player only.
31055                         UseTextureAlpha  bool
31056                         DmgTextureMod    Texture // suffix
31057                         Shaded           bool
31058                         ShowOnMinimap    bool
31059                         NametagBG        color.NRGBA
31060                 }))(obj)).UseTextureAlpha
31061                 switch n := read8(r); n {
31062                 case 0:
31063                         *p = false
31064                 case 1:
31065                         *p = true
31066                 default:
31067                         chk(fmt.Errorf("invalid bool: %d", n))
31068                 }
31069         }
31070         if err := pcall(func() {
31071                 ((*(*(struct {
31072                         MaxHP            uint16 // Player only.
31073                         CollideWithNodes bool
31074                         Weight           float32 // deprecated
31075                         ColBox, SelBox   Box
31076                         Pointable        bool
31077                         Visual           string
31078                         VisualSize       [3]float32
31079                         Textures         []Texture
31080                         SpriteSheetSize  [2]int16 // in sprites.
31081                         SpritePos        [2]int16 // in sprite sheet.
31082                         Visible          bool
31083                         MakeFootstepSnds bool
31084                         RotateSpeed      float32 // in radians per second.
31085                         Mesh             string
31086                         Colors           []color.NRGBA
31087                         CollideWithAOs   bool
31088                         StepHeight       float32
31089                         FaceRotateDir    bool
31090                         FaceRotateDirOff float32 // in degrees.
31091                         BackfaceCull     bool
31092                         Nametag          string
31093                         NametagColor     color.NRGBA
31094                         FaceRotateSpeed  float32 // in degrees per second.
31095                         Infotext         string
31096                         Itemstring       string
31097                         Glow             int8
31098                         MaxBreath        uint16  // Player only.
31099                         EyeHeight        float32 // Player only.
31100                         ZoomFOV          float32 // in degrees. Player only.
31101                         UseTextureAlpha  bool
31102                         DmgTextureMod    Texture // suffix
31103                         Shaded           bool
31104                         ShowOnMinimap    bool
31105                         NametagBG        color.NRGBA
31106                 }))(obj)).DmgTextureMod).deserialize(r)
31107         }); err != nil {
31108                 if err == io.EOF {
31109                         chk(io.EOF)
31110                 }
31111                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
31112         }
31113         {
31114                 p := &(*(*(struct {
31115                         MaxHP            uint16 // Player only.
31116                         CollideWithNodes bool
31117                         Weight           float32 // deprecated
31118                         ColBox, SelBox   Box
31119                         Pointable        bool
31120                         Visual           string
31121                         VisualSize       [3]float32
31122                         Textures         []Texture
31123                         SpriteSheetSize  [2]int16 // in sprites.
31124                         SpritePos        [2]int16 // in sprite sheet.
31125                         Visible          bool
31126                         MakeFootstepSnds bool
31127                         RotateSpeed      float32 // in radians per second.
31128                         Mesh             string
31129                         Colors           []color.NRGBA
31130                         CollideWithAOs   bool
31131                         StepHeight       float32
31132                         FaceRotateDir    bool
31133                         FaceRotateDirOff float32 // in degrees.
31134                         BackfaceCull     bool
31135                         Nametag          string
31136                         NametagColor     color.NRGBA
31137                         FaceRotateSpeed  float32 // in degrees per second.
31138                         Infotext         string
31139                         Itemstring       string
31140                         Glow             int8
31141                         MaxBreath        uint16  // Player only.
31142                         EyeHeight        float32 // Player only.
31143                         ZoomFOV          float32 // in degrees. Player only.
31144                         UseTextureAlpha  bool
31145                         DmgTextureMod    Texture // suffix
31146                         Shaded           bool
31147                         ShowOnMinimap    bool
31148                         NametagBG        color.NRGBA
31149                 }))(obj)).Shaded
31150                 switch n := read8(r); n {
31151                 case 0:
31152                         *p = false
31153                 case 1:
31154                         *p = true
31155                 default:
31156                         chk(fmt.Errorf("invalid bool: %d", n))
31157                 }
31158         }
31159         {
31160                 p := &(*(*(struct {
31161                         MaxHP            uint16 // Player only.
31162                         CollideWithNodes bool
31163                         Weight           float32 // deprecated
31164                         ColBox, SelBox   Box
31165                         Pointable        bool
31166                         Visual           string
31167                         VisualSize       [3]float32
31168                         Textures         []Texture
31169                         SpriteSheetSize  [2]int16 // in sprites.
31170                         SpritePos        [2]int16 // in sprite sheet.
31171                         Visible          bool
31172                         MakeFootstepSnds bool
31173                         RotateSpeed      float32 // in radians per second.
31174                         Mesh             string
31175                         Colors           []color.NRGBA
31176                         CollideWithAOs   bool
31177                         StepHeight       float32
31178                         FaceRotateDir    bool
31179                         FaceRotateDirOff float32 // in degrees.
31180                         BackfaceCull     bool
31181                         Nametag          string
31182                         NametagColor     color.NRGBA
31183                         FaceRotateSpeed  float32 // in degrees per second.
31184                         Infotext         string
31185                         Itemstring       string
31186                         Glow             int8
31187                         MaxBreath        uint16  // Player only.
31188                         EyeHeight        float32 // Player only.
31189                         ZoomFOV          float32 // in degrees. Player only.
31190                         UseTextureAlpha  bool
31191                         DmgTextureMod    Texture // suffix
31192                         Shaded           bool
31193                         ShowOnMinimap    bool
31194                         NametagBG        color.NRGBA
31195                 }))(obj)).ShowOnMinimap
31196                 switch n := read8(r); n {
31197                 case 0:
31198                         *p = false
31199                 case 1:
31200                         *p = true
31201                 default:
31202                         chk(fmt.Errorf("invalid bool: %d", n))
31203                 }
31204         }
31205         {
31206                 p := &(*(*(struct {
31207                         MaxHP            uint16 // Player only.
31208                         CollideWithNodes bool
31209                         Weight           float32 // deprecated
31210                         ColBox, SelBox   Box
31211                         Pointable        bool
31212                         Visual           string
31213                         VisualSize       [3]float32
31214                         Textures         []Texture
31215                         SpriteSheetSize  [2]int16 // in sprites.
31216                         SpritePos        [2]int16 // in sprite sheet.
31217                         Visible          bool
31218                         MakeFootstepSnds bool
31219                         RotateSpeed      float32 // in radians per second.
31220                         Mesh             string
31221                         Colors           []color.NRGBA
31222                         CollideWithAOs   bool
31223                         StepHeight       float32
31224                         FaceRotateDir    bool
31225                         FaceRotateDirOff float32 // in degrees.
31226                         BackfaceCull     bool
31227                         Nametag          string
31228                         NametagColor     color.NRGBA
31229                         FaceRotateSpeed  float32 // in degrees per second.
31230                         Infotext         string
31231                         Itemstring       string
31232                         Glow             int8
31233                         MaxBreath        uint16  // Player only.
31234                         EyeHeight        float32 // Player only.
31235                         ZoomFOV          float32 // in degrees. Player only.
31236                         UseTextureAlpha  bool
31237                         DmgTextureMod    Texture // suffix
31238                         Shaded           bool
31239                         ShowOnMinimap    bool
31240                         NametagBG        color.NRGBA
31241                 }))(obj)).NametagBG
31242                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31243         }
31244 }
31245
31246 func (obj *AOPos) serialize(w io.Writer) {
31247         if err := pcall(func() {
31248                 ((*(*(struct {
31249                         Pos
31250                         Vel, Acc Vec
31251                         Rot      [3]float32
31252
31253                         Interpolate    bool
31254                         End            bool
31255                         UpdateInterval float32
31256                 }))(obj)).Pos).serialize(w)
31257         }); err != nil {
31258                 if err == io.EOF {
31259                         chk(io.EOF)
31260                 }
31261                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
31262         }
31263         if err := pcall(func() {
31264                 ((*(*(struct {
31265                         Pos
31266                         Vel, Acc Vec
31267                         Rot      [3]float32
31268
31269                         Interpolate    bool
31270                         End            bool
31271                         UpdateInterval float32
31272                 }))(obj)).Vel).serialize(w)
31273         }); err != nil {
31274                 if err == io.EOF {
31275                         chk(io.EOF)
31276                 }
31277                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31278         }
31279         if err := pcall(func() {
31280                 ((*(*(struct {
31281                         Pos
31282                         Vel, Acc Vec
31283                         Rot      [3]float32
31284
31285                         Interpolate    bool
31286                         End            bool
31287                         UpdateInterval float32
31288                 }))(obj)).Acc).serialize(w)
31289         }); err != nil {
31290                 if err == io.EOF {
31291                         chk(io.EOF)
31292                 }
31293                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31294         }
31295         for local358 := range (*(*(struct {
31296                 Pos
31297                 Vel, Acc Vec
31298                 Rot      [3]float32
31299
31300                 Interpolate    bool
31301                 End            bool
31302                 UpdateInterval float32
31303         }))(obj)).Rot {
31304                 {
31305                         x := ((*(*(struct {
31306                                 Pos
31307                                 Vel, Acc Vec
31308                                 Rot      [3]float32
31309
31310                                 Interpolate    bool
31311                                 End            bool
31312                                 UpdateInterval float32
31313                         }))(obj)).Rot)[local358]
31314                         write32(w, math.Float32bits(x))
31315                 }
31316         }
31317         {
31318                 x := (*(*(struct {
31319                         Pos
31320                         Vel, Acc Vec
31321                         Rot      [3]float32
31322
31323                         Interpolate    bool
31324                         End            bool
31325                         UpdateInterval float32
31326                 }))(obj)).Interpolate
31327                 if x {
31328                         write8(w, 1)
31329                 } else {
31330                         write8(w, 0)
31331                 }
31332         }
31333         {
31334                 x := (*(*(struct {
31335                         Pos
31336                         Vel, Acc Vec
31337                         Rot      [3]float32
31338
31339                         Interpolate    bool
31340                         End            bool
31341                         UpdateInterval float32
31342                 }))(obj)).End
31343                 if x {
31344                         write8(w, 1)
31345                 } else {
31346                         write8(w, 0)
31347                 }
31348         }
31349         {
31350                 x := (*(*(struct {
31351                         Pos
31352                         Vel, Acc Vec
31353                         Rot      [3]float32
31354
31355                         Interpolate    bool
31356                         End            bool
31357                         UpdateInterval float32
31358                 }))(obj)).UpdateInterval
31359                 write32(w, math.Float32bits(x))
31360         }
31361 }
31362
31363 func (obj *AOPos) deserialize(r io.Reader) {
31364         if err := pcall(func() {
31365                 ((*(*(struct {
31366                         Pos
31367                         Vel, Acc Vec
31368                         Rot      [3]float32
31369
31370                         Interpolate    bool
31371                         End            bool
31372                         UpdateInterval float32
31373                 }))(obj)).Pos).deserialize(r)
31374         }); err != nil {
31375                 if err == io.EOF {
31376                         chk(io.EOF)
31377                 }
31378                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
31379         }
31380         if err := pcall(func() {
31381                 ((*(*(struct {
31382                         Pos
31383                         Vel, Acc Vec
31384                         Rot      [3]float32
31385
31386                         Interpolate    bool
31387                         End            bool
31388                         UpdateInterval float32
31389                 }))(obj)).Vel).deserialize(r)
31390         }); err != nil {
31391                 if err == io.EOF {
31392                         chk(io.EOF)
31393                 }
31394                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31395         }
31396         if err := pcall(func() {
31397                 ((*(*(struct {
31398                         Pos
31399                         Vel, Acc Vec
31400                         Rot      [3]float32
31401
31402                         Interpolate    bool
31403                         End            bool
31404                         UpdateInterval float32
31405                 }))(obj)).Acc).deserialize(r)
31406         }); err != nil {
31407                 if err == io.EOF {
31408                         chk(io.EOF)
31409                 }
31410                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31411         }
31412         for local359 := range (*(*(struct {
31413                 Pos
31414                 Vel, Acc Vec
31415                 Rot      [3]float32
31416
31417                 Interpolate    bool
31418                 End            bool
31419                 UpdateInterval float32
31420         }))(obj)).Rot {
31421                 {
31422                         p := &((*(*(struct {
31423                                 Pos
31424                                 Vel, Acc Vec
31425                                 Rot      [3]float32
31426
31427                                 Interpolate    bool
31428                                 End            bool
31429                                 UpdateInterval float32
31430                         }))(obj)).Rot)[local359]
31431                         *p = math.Float32frombits(read32(r))
31432                 }
31433         }
31434         {
31435                 p := &(*(*(struct {
31436                         Pos
31437                         Vel, Acc Vec
31438                         Rot      [3]float32
31439
31440                         Interpolate    bool
31441                         End            bool
31442                         UpdateInterval float32
31443                 }))(obj)).Interpolate
31444                 switch n := read8(r); n {
31445                 case 0:
31446                         *p = false
31447                 case 1:
31448                         *p = true
31449                 default:
31450                         chk(fmt.Errorf("invalid bool: %d", n))
31451                 }
31452         }
31453         {
31454                 p := &(*(*(struct {
31455                         Pos
31456                         Vel, Acc Vec
31457                         Rot      [3]float32
31458
31459                         Interpolate    bool
31460                         End            bool
31461                         UpdateInterval float32
31462                 }))(obj)).End
31463                 switch n := read8(r); n {
31464                 case 0:
31465                         *p = false
31466                 case 1:
31467                         *p = true
31468                 default:
31469                         chk(fmt.Errorf("invalid bool: %d", n))
31470                 }
31471         }
31472         {
31473                 p := &(*(*(struct {
31474                         Pos
31475                         Vel, Acc Vec
31476                         Rot      [3]float32
31477
31478                         Interpolate    bool
31479                         End            bool
31480                         UpdateInterval float32
31481                 }))(obj)).UpdateInterval
31482                 *p = math.Float32frombits(read32(r))
31483         }
31484 }
31485
31486 func (obj *AOSprite) serialize(w io.Writer) {
31487         for local360 := range (*(*(struct {
31488                 Frame0          [2]int16
31489                 Frames          uint16
31490                 FrameDuration   float32
31491                 ViewAngleFrames bool
31492         }))(obj)).Frame0 {
31493                 {
31494                         x := ((*(*(struct {
31495                                 Frame0          [2]int16
31496                                 Frames          uint16
31497                                 FrameDuration   float32
31498                                 ViewAngleFrames bool
31499                         }))(obj)).Frame0)[local360]
31500                         write16(w, uint16(x))
31501                 }
31502         }
31503         {
31504                 x := (*(*(struct {
31505                         Frame0          [2]int16
31506                         Frames          uint16
31507                         FrameDuration   float32
31508                         ViewAngleFrames bool
31509                 }))(obj)).Frames
31510                 write16(w, uint16(x))
31511         }
31512         {
31513                 x := (*(*(struct {
31514                         Frame0          [2]int16
31515                         Frames          uint16
31516                         FrameDuration   float32
31517                         ViewAngleFrames bool
31518                 }))(obj)).FrameDuration
31519                 write32(w, math.Float32bits(x))
31520         }
31521         {
31522                 x := (*(*(struct {
31523                         Frame0          [2]int16
31524                         Frames          uint16
31525                         FrameDuration   float32
31526                         ViewAngleFrames bool
31527                 }))(obj)).ViewAngleFrames
31528                 if x {
31529                         write8(w, 1)
31530                 } else {
31531                         write8(w, 0)
31532                 }
31533         }
31534 }
31535
31536 func (obj *AOSprite) deserialize(r io.Reader) {
31537         for local361 := range (*(*(struct {
31538                 Frame0          [2]int16
31539                 Frames          uint16
31540                 FrameDuration   float32
31541                 ViewAngleFrames bool
31542         }))(obj)).Frame0 {
31543                 {
31544                         p := &((*(*(struct {
31545                                 Frame0          [2]int16
31546                                 Frames          uint16
31547                                 FrameDuration   float32
31548                                 ViewAngleFrames bool
31549                         }))(obj)).Frame0)[local361]
31550                         *p = int16(read16(r))
31551                 }
31552         }
31553         {
31554                 p := &(*(*(struct {
31555                         Frame0          [2]int16
31556                         Frames          uint16
31557                         FrameDuration   float32
31558                         ViewAngleFrames bool
31559                 }))(obj)).Frames
31560                 *p = read16(r)
31561         }
31562         {
31563                 p := &(*(*(struct {
31564                         Frame0          [2]int16
31565                         Frames          uint16
31566                         FrameDuration   float32
31567                         ViewAngleFrames bool
31568                 }))(obj)).FrameDuration
31569                 *p = math.Float32frombits(read32(r))
31570         }
31571         {
31572                 p := &(*(*(struct {
31573                         Frame0          [2]int16
31574                         Frames          uint16
31575                         FrameDuration   float32
31576                         ViewAngleFrames bool
31577                 }))(obj)).ViewAngleFrames
31578                 switch n := read8(r); n {
31579                 case 0:
31580                         *p = false
31581                 case 1:
31582                         *p = true
31583                 default:
31584                         chk(fmt.Errorf("invalid bool: %d", n))
31585                 }
31586         }
31587 }
31588
31589 func (obj *Group) serialize(w io.Writer) {
31590         if len(([]byte((*(*(struct {
31591                 Name   string
31592                 Rating int16
31593         }))(obj)).Name))) > math.MaxUint16 {
31594                 chk(ErrTooLong)
31595         }
31596         {
31597                 x := uint16(len(([]byte((*(*(struct {
31598                         Name   string
31599                         Rating int16
31600                 }))(obj)).Name))))
31601                 write16(w, uint16(x))
31602         }
31603         {
31604                 _, err := w.Write(([]byte((*(*(struct {
31605                         Name   string
31606                         Rating int16
31607                 }))(obj)).Name))[:])
31608                 chk(err)
31609         }
31610         {
31611                 x := (*(*(struct {
31612                         Name   string
31613                         Rating int16
31614                 }))(obj)).Rating
31615                 write16(w, uint16(x))
31616         }
31617 }
31618
31619 func (obj *Group) deserialize(r io.Reader) {
31620         var local362 []uint8
31621         var local363 uint16
31622         {
31623                 p := &local363
31624                 *p = read16(r)
31625         }
31626         (local362) = make([]uint8, local363)
31627         {
31628                 _, err := io.ReadFull(r, (local362)[:])
31629                 chk(err)
31630         }
31631         ((*(*(struct {
31632                 Name   string
31633                 Rating int16
31634         }))(obj)).Name) = string(local362)
31635         {
31636                 p := &(*(*(struct {
31637                         Name   string
31638                         Rating int16
31639                 }))(obj)).Rating
31640                 *p = int16(read16(r))
31641         }
31642 }
31643
31644 func (obj *AOAnim) serialize(w io.Writer) {
31645         for local364 := range (*(*(struct {
31646                 Frames [2]int32
31647                 Speed  float32
31648                 Blend  float32
31649                 NoLoop bool
31650         }))(obj)).Frames {
31651                 {
31652                         x := ((*(*(struct {
31653                                 Frames [2]int32
31654                                 Speed  float32
31655                                 Blend  float32
31656                                 NoLoop bool
31657                         }))(obj)).Frames)[local364]
31658                         write32(w, uint32(x))
31659                 }
31660         }
31661         {
31662                 x := (*(*(struct {
31663                         Frames [2]int32
31664                         Speed  float32
31665                         Blend  float32
31666                         NoLoop bool
31667                 }))(obj)).Speed
31668                 write32(w, math.Float32bits(x))
31669         }
31670         {
31671                 x := (*(*(struct {
31672                         Frames [2]int32
31673                         Speed  float32
31674                         Blend  float32
31675                         NoLoop bool
31676                 }))(obj)).Blend
31677                 write32(w, math.Float32bits(x))
31678         }
31679         {
31680                 x := (*(*(struct {
31681                         Frames [2]int32
31682                         Speed  float32
31683                         Blend  float32
31684                         NoLoop bool
31685                 }))(obj)).NoLoop
31686                 if x {
31687                         write8(w, 1)
31688                 } else {
31689                         write8(w, 0)
31690                 }
31691         }
31692 }
31693
31694 func (obj *AOAnim) deserialize(r io.Reader) {
31695         for local365 := range (*(*(struct {
31696                 Frames [2]int32
31697                 Speed  float32
31698                 Blend  float32
31699                 NoLoop bool
31700         }))(obj)).Frames {
31701                 {
31702                         p := &((*(*(struct {
31703                                 Frames [2]int32
31704                                 Speed  float32
31705                                 Blend  float32
31706                                 NoLoop bool
31707                         }))(obj)).Frames)[local365]
31708                         *p = int32(read32(r))
31709                 }
31710         }
31711         {
31712                 p := &(*(*(struct {
31713                         Frames [2]int32
31714                         Speed  float32
31715                         Blend  float32
31716                         NoLoop bool
31717                 }))(obj)).Speed
31718                 *p = math.Float32frombits(read32(r))
31719         }
31720         {
31721                 p := &(*(*(struct {
31722                         Frames [2]int32
31723                         Speed  float32
31724                         Blend  float32
31725                         NoLoop bool
31726                 }))(obj)).Blend
31727                 *p = math.Float32frombits(read32(r))
31728         }
31729         {
31730                 p := &(*(*(struct {
31731                         Frames [2]int32
31732                         Speed  float32
31733                         Blend  float32
31734                         NoLoop bool
31735                 }))(obj)).NoLoop
31736                 switch n := read8(r); n {
31737                 case 0:
31738                         *p = false
31739                 case 1:
31740                         *p = true
31741                 default:
31742                         chk(fmt.Errorf("invalid bool: %d", n))
31743                 }
31744         }
31745 }
31746
31747 func (obj *AOBonePos) serialize(w io.Writer) {
31748         if err := pcall(func() {
31749                 ((*(*(struct {
31750                         Pos Vec
31751                         Rot [3]float32
31752                 }))(obj)).Pos).serialize(w)
31753         }); err != nil {
31754                 if err == io.EOF {
31755                         chk(io.EOF)
31756                 }
31757                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31758         }
31759         for local366 := range (*(*(struct {
31760                 Pos Vec
31761                 Rot [3]float32
31762         }))(obj)).Rot {
31763                 {
31764                         x := ((*(*(struct {
31765                                 Pos Vec
31766                                 Rot [3]float32
31767                         }))(obj)).Rot)[local366]
31768                         write32(w, math.Float32bits(x))
31769                 }
31770         }
31771 }
31772
31773 func (obj *AOBonePos) deserialize(r io.Reader) {
31774         if err := pcall(func() {
31775                 ((*(*(struct {
31776                         Pos Vec
31777                         Rot [3]float32
31778                 }))(obj)).Pos).deserialize(r)
31779         }); err != nil {
31780                 if err == io.EOF {
31781                         chk(io.EOF)
31782                 }
31783                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31784         }
31785         for local367 := range (*(*(struct {
31786                 Pos Vec
31787                 Rot [3]float32
31788         }))(obj)).Rot {
31789                 {
31790                         p := &((*(*(struct {
31791                                 Pos Vec
31792                                 Rot [3]float32
31793                         }))(obj)).Rot)[local367]
31794                         *p = math.Float32frombits(read32(r))
31795                 }
31796         }
31797 }
31798
31799 func (obj *AOAttach) serialize(w io.Writer) {
31800         if err := pcall(func() {
31801                 ((*(*(struct {
31802                         ParentID     AOID
31803                         Bone         string
31804                         Pos          Vec
31805                         Rot          [3]float32
31806                         ForceVisible bool
31807                 }))(obj)).ParentID).serialize(w)
31808         }); err != nil {
31809                 if err == io.EOF {
31810                         chk(io.EOF)
31811                 }
31812                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
31813         }
31814         if len(([]byte((*(*(struct {
31815                 ParentID     AOID
31816                 Bone         string
31817                 Pos          Vec
31818                 Rot          [3]float32
31819                 ForceVisible bool
31820         }))(obj)).Bone))) > math.MaxUint16 {
31821                 chk(ErrTooLong)
31822         }
31823         {
31824                 x := uint16(len(([]byte((*(*(struct {
31825                         ParentID     AOID
31826                         Bone         string
31827                         Pos          Vec
31828                         Rot          [3]float32
31829                         ForceVisible bool
31830                 }))(obj)).Bone))))
31831                 write16(w, uint16(x))
31832         }
31833         {
31834                 _, err := w.Write(([]byte((*(*(struct {
31835                         ParentID     AOID
31836                         Bone         string
31837                         Pos          Vec
31838                         Rot          [3]float32
31839                         ForceVisible bool
31840                 }))(obj)).Bone))[:])
31841                 chk(err)
31842         }
31843         if err := pcall(func() {
31844                 ((*(*(struct {
31845                         ParentID     AOID
31846                         Bone         string
31847                         Pos          Vec
31848                         Rot          [3]float32
31849                         ForceVisible bool
31850                 }))(obj)).Pos).serialize(w)
31851         }); err != nil {
31852                 if err == io.EOF {
31853                         chk(io.EOF)
31854                 }
31855                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31856         }
31857         for local368 := range (*(*(struct {
31858                 ParentID     AOID
31859                 Bone         string
31860                 Pos          Vec
31861                 Rot          [3]float32
31862                 ForceVisible bool
31863         }))(obj)).Rot {
31864                 {
31865                         x := ((*(*(struct {
31866                                 ParentID     AOID
31867                                 Bone         string
31868                                 Pos          Vec
31869                                 Rot          [3]float32
31870                                 ForceVisible bool
31871                         }))(obj)).Rot)[local368]
31872                         write32(w, math.Float32bits(x))
31873                 }
31874         }
31875         {
31876                 x := (*(*(struct {
31877                         ParentID     AOID
31878                         Bone         string
31879                         Pos          Vec
31880                         Rot          [3]float32
31881                         ForceVisible bool
31882                 }))(obj)).ForceVisible
31883                 if x {
31884                         write8(w, 1)
31885                 } else {
31886                         write8(w, 0)
31887                 }
31888         }
31889 }
31890
31891 func (obj *AOAttach) deserialize(r io.Reader) {
31892         if err := pcall(func() {
31893                 ((*(*(struct {
31894                         ParentID     AOID
31895                         Bone         string
31896                         Pos          Vec
31897                         Rot          [3]float32
31898                         ForceVisible bool
31899                 }))(obj)).ParentID).deserialize(r)
31900         }); err != nil {
31901                 if err == io.EOF {
31902                         chk(io.EOF)
31903                 }
31904                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
31905         }
31906         var local369 []uint8
31907         var local370 uint16
31908         {
31909                 p := &local370
31910                 *p = read16(r)
31911         }
31912         (local369) = make([]uint8, local370)
31913         {
31914                 _, err := io.ReadFull(r, (local369)[:])
31915                 chk(err)
31916         }
31917         ((*(*(struct {
31918                 ParentID     AOID
31919                 Bone         string
31920                 Pos          Vec
31921                 Rot          [3]float32
31922                 ForceVisible bool
31923         }))(obj)).Bone) = string(local369)
31924         if err := pcall(func() {
31925                 ((*(*(struct {
31926                         ParentID     AOID
31927                         Bone         string
31928                         Pos          Vec
31929                         Rot          [3]float32
31930                         ForceVisible bool
31931                 }))(obj)).Pos).deserialize(r)
31932         }); err != nil {
31933                 if err == io.EOF {
31934                         chk(io.EOF)
31935                 }
31936                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
31937         }
31938         for local371 := range (*(*(struct {
31939                 ParentID     AOID
31940                 Bone         string
31941                 Pos          Vec
31942                 Rot          [3]float32
31943                 ForceVisible bool
31944         }))(obj)).Rot {
31945                 {
31946                         p := &((*(*(struct {
31947                                 ParentID     AOID
31948                                 Bone         string
31949                                 Pos          Vec
31950                                 Rot          [3]float32
31951                                 ForceVisible bool
31952                         }))(obj)).Rot)[local371]
31953                         *p = math.Float32frombits(read32(r))
31954                 }
31955         }
31956         {
31957                 p := &(*(*(struct {
31958                         ParentID     AOID
31959                         Bone         string
31960                         Pos          Vec
31961                         Rot          [3]float32
31962                         ForceVisible bool
31963                 }))(obj)).ForceVisible
31964                 switch n := read8(r); n {
31965                 case 0:
31966                         *p = false
31967                 case 1:
31968                         *p = true
31969                 default:
31970                         chk(fmt.Errorf("invalid bool: %d", n))
31971                 }
31972         }
31973 }
31974
31975 func (obj *AOPhysOverride) serialize(w io.Writer) {
31976         {
31977                 x := (*(*(struct {
31978                         Walk, Jump, Gravity float32
31979
31980                         // Player only.
31981                         NoSneak, NoSneakGlitch, OldSneak bool
31982                 }))(obj)).Walk
31983                 write32(w, math.Float32bits(x))
31984         }
31985         {
31986                 x := (*(*(struct {
31987                         Walk, Jump, Gravity float32
31988
31989                         // Player only.
31990                         NoSneak, NoSneakGlitch, OldSneak bool
31991                 }))(obj)).Jump
31992                 write32(w, math.Float32bits(x))
31993         }
31994         {
31995                 x := (*(*(struct {
31996                         Walk, Jump, Gravity float32
31997
31998                         // Player only.
31999                         NoSneak, NoSneakGlitch, OldSneak bool
32000                 }))(obj)).Gravity
32001                 write32(w, math.Float32bits(x))
32002         }
32003         {
32004                 x := (*(*(struct {
32005                         Walk, Jump, Gravity float32
32006
32007                         // Player only.
32008                         NoSneak, NoSneakGlitch, OldSneak bool
32009                 }))(obj)).NoSneak
32010                 if x {
32011                         write8(w, 1)
32012                 } else {
32013                         write8(w, 0)
32014                 }
32015         }
32016         {
32017                 x := (*(*(struct {
32018                         Walk, Jump, Gravity float32
32019
32020                         // Player only.
32021                         NoSneak, NoSneakGlitch, OldSneak bool
32022                 }))(obj)).NoSneakGlitch
32023                 if x {
32024                         write8(w, 1)
32025                 } else {
32026                         write8(w, 0)
32027                 }
32028         }
32029         {
32030                 x := (*(*(struct {
32031                         Walk, Jump, Gravity float32
32032
32033                         // Player only.
32034                         NoSneak, NoSneakGlitch, OldSneak bool
32035                 }))(obj)).OldSneak
32036                 if x {
32037                         write8(w, 1)
32038                 } else {
32039                         write8(w, 0)
32040                 }
32041         }
32042 }
32043
32044 func (obj *AOPhysOverride) deserialize(r io.Reader) {
32045         {
32046                 p := &(*(*(struct {
32047                         Walk, Jump, Gravity float32
32048
32049                         // Player only.
32050                         NoSneak, NoSneakGlitch, OldSneak bool
32051                 }))(obj)).Walk
32052                 *p = math.Float32frombits(read32(r))
32053         }
32054         {
32055                 p := &(*(*(struct {
32056                         Walk, Jump, Gravity float32
32057
32058                         // Player only.
32059                         NoSneak, NoSneakGlitch, OldSneak bool
32060                 }))(obj)).Jump
32061                 *p = math.Float32frombits(read32(r))
32062         }
32063         {
32064                 p := &(*(*(struct {
32065                         Walk, Jump, Gravity float32
32066
32067                         // Player only.
32068                         NoSneak, NoSneakGlitch, OldSneak bool
32069                 }))(obj)).Gravity
32070                 *p = math.Float32frombits(read32(r))
32071         }
32072         {
32073                 p := &(*(*(struct {
32074                         Walk, Jump, Gravity float32
32075
32076                         // Player only.
32077                         NoSneak, NoSneakGlitch, OldSneak bool
32078                 }))(obj)).NoSneak
32079                 switch n := read8(r); n {
32080                 case 0:
32081                         *p = false
32082                 case 1:
32083                         *p = true
32084                 default:
32085                         chk(fmt.Errorf("invalid bool: %d", n))
32086                 }
32087         }
32088         {
32089                 p := &(*(*(struct {
32090                         Walk, Jump, Gravity float32
32091
32092                         // Player only.
32093                         NoSneak, NoSneakGlitch, OldSneak bool
32094                 }))(obj)).NoSneakGlitch
32095                 switch n := read8(r); n {
32096                 case 0:
32097                         *p = false
32098                 case 1:
32099                         *p = true
32100                 default:
32101                         chk(fmt.Errorf("invalid bool: %d", n))
32102                 }
32103         }
32104         {
32105                 p := &(*(*(struct {
32106                         Walk, Jump, Gravity float32
32107
32108                         // Player only.
32109                         NoSneak, NoSneakGlitch, OldSneak bool
32110                 }))(obj)).OldSneak
32111                 switch n := read8(r); n {
32112                 case 0:
32113                         *p = false
32114                 case 1:
32115                         *p = true
32116                 default:
32117                         chk(fmt.Errorf("invalid bool: %d", n))
32118                 }
32119         }
32120 }
32121
32122 func (obj *aoType) serialize(w io.Writer) {
32123         {
32124                 x := *(*(uint8))(obj)
32125                 write8(w, uint8(x))
32126         }
32127 }
32128
32129 func (obj *aoType) deserialize(r io.Reader) {
32130         {
32131                 p := &*(*(uint8))(obj)
32132                 *p = read8(r)
32133         }
32134 }
32135
32136 func (obj *NodeMetaField) serialize(w io.Writer) {
32137         if err := pcall(func() {
32138                 ((*(*(struct {
32139                         Field
32140                         Private bool
32141                 }))(obj)).Field).serialize(w)
32142         }); err != nil {
32143                 if err == io.EOF {
32144                         chk(io.EOF)
32145                 }
32146                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
32147         }
32148         {
32149                 x := (*(*(struct {
32150                         Field
32151                         Private bool
32152                 }))(obj)).Private
32153                 if x {
32154                         write8(w, 1)
32155                 } else {
32156                         write8(w, 0)
32157                 }
32158         }
32159 }
32160
32161 func (obj *NodeMetaField) deserialize(r io.Reader) {
32162         if err := pcall(func() {
32163                 ((*(*(struct {
32164                         Field
32165                         Private bool
32166                 }))(obj)).Field).deserialize(r)
32167         }); err != nil {
32168                 if err == io.EOF {
32169                         chk(io.EOF)
32170                 }
32171                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
32172         }
32173         {
32174                 p := &(*(*(struct {
32175                         Field
32176                         Private bool
32177                 }))(obj)).Private
32178                 switch n := read8(r); n {
32179                 case 0:
32180                         *p = false
32181                 case 1:
32182                         *p = true
32183                 default:
32184                         chk(fmt.Errorf("invalid bool: %d", n))
32185                 }
32186         }
32187 }
32188
32189 func (obj *MinimapType) serialize(w io.Writer) {
32190         {
32191                 x := *(*(uint16))(obj)
32192                 write16(w, uint16(x))
32193         }
32194 }
32195
32196 func (obj *MinimapType) deserialize(r io.Reader) {
32197         {
32198                 p := &*(*(uint16))(obj)
32199                 *p = read16(r)
32200         }
32201 }
32202
32203 func (obj *Param1Type) serialize(w io.Writer) {
32204         {
32205                 x := *(*(uint8))(obj)
32206                 write8(w, uint8(x))
32207         }
32208 }
32209
32210 func (obj *Param1Type) deserialize(r io.Reader) {
32211         {
32212                 p := &*(*(uint8))(obj)
32213                 *p = read8(r)
32214         }
32215 }
32216
32217 func (obj *Param2Type) serialize(w io.Writer) {
32218         {
32219                 x := *(*(uint8))(obj)
32220                 write8(w, uint8(x))
32221         }
32222 }
32223
32224 func (obj *Param2Type) deserialize(r io.Reader) {
32225         {
32226                 p := &*(*(uint8))(obj)
32227                 *p = read8(r)
32228         }
32229 }
32230
32231 func (obj *DrawType) serialize(w io.Writer) {
32232         {
32233                 x := *(*(uint8))(obj)
32234                 write8(w, uint8(x))
32235         }
32236 }
32237
32238 func (obj *DrawType) deserialize(r io.Reader) {
32239         {
32240                 p := &*(*(uint8))(obj)
32241                 *p = read8(r)
32242         }
32243 }
32244
32245 func (obj *TileDef) serialize(w io.Writer) {
32246         {
32247                 local372 := uint8(6)
32248                 {
32249                         x := local372
32250                         write8(w, uint8(x))
32251                 }
32252         }
32253         if err := pcall(func() {
32254                 ((*(*(struct {
32255                         Texture
32256                         Anim  TileAnim
32257                         Flags TileFlags
32258
32259                         //mt:if %s.Flags&TileColor != 0
32260                         R, G, B uint8
32261
32262                         //mt:if %s.Flags&TileScale != 0
32263                         Scale uint8
32264
32265                         //mt:if %s.Flags&TileAlign != 0
32266                         Align AlignType
32267                 }))(obj)).Texture).serialize(w)
32268         }); err != nil {
32269                 if err == io.EOF {
32270                         chk(io.EOF)
32271                 }
32272                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
32273         }
32274         if err := pcall(func() {
32275                 ((*(*(struct {
32276                         Texture
32277                         Anim  TileAnim
32278                         Flags TileFlags
32279
32280                         //mt:if %s.Flags&TileColor != 0
32281                         R, G, B uint8
32282
32283                         //mt:if %s.Flags&TileScale != 0
32284                         Scale uint8
32285
32286                         //mt:if %s.Flags&TileAlign != 0
32287                         Align AlignType
32288                 }))(obj)).Anim).serialize(w)
32289         }); err != nil {
32290                 if err == io.EOF {
32291                         chk(io.EOF)
32292                 }
32293                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
32294         }
32295         if err := pcall(func() {
32296                 ((*(*(struct {
32297                         Texture
32298                         Anim  TileAnim
32299                         Flags TileFlags
32300
32301                         //mt:if %s.Flags&TileColor != 0
32302                         R, G, B uint8
32303
32304                         //mt:if %s.Flags&TileScale != 0
32305                         Scale uint8
32306
32307                         //mt:if %s.Flags&TileAlign != 0
32308                         Align AlignType
32309                 }))(obj)).Flags).serialize(w)
32310         }); err != nil {
32311                 if err == io.EOF {
32312                         chk(io.EOF)
32313                 }
32314                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
32315         }
32316         if (*(*(struct {
32317                 Texture
32318                 Anim  TileAnim
32319                 Flags TileFlags
32320
32321                 //mt:if %s.Flags&TileColor != 0
32322                 R, G, B uint8
32323
32324                 //mt:if %s.Flags&TileScale != 0
32325                 Scale uint8
32326
32327                 //mt:if %s.Flags&TileAlign != 0
32328                 Align AlignType
32329         }))(obj)).Flags&TileColor != 0 {
32330                 {
32331                         x := (*(*(struct {
32332                                 Texture
32333                                 Anim  TileAnim
32334                                 Flags TileFlags
32335
32336                                 //mt:if %s.Flags&TileColor != 0
32337                                 R, G, B uint8
32338
32339                                 //mt:if %s.Flags&TileScale != 0
32340                                 Scale uint8
32341
32342                                 //mt:if %s.Flags&TileAlign != 0
32343                                 Align AlignType
32344                         }))(obj)).R
32345                         write8(w, uint8(x))
32346                 }
32347                 {
32348                         x := (*(*(struct {
32349                                 Texture
32350                                 Anim  TileAnim
32351                                 Flags TileFlags
32352
32353                                 //mt:if %s.Flags&TileColor != 0
32354                                 R, G, B uint8
32355
32356                                 //mt:if %s.Flags&TileScale != 0
32357                                 Scale uint8
32358
32359                                 //mt:if %s.Flags&TileAlign != 0
32360                                 Align AlignType
32361                         }))(obj)).G
32362                         write8(w, uint8(x))
32363                 }
32364                 {
32365                         x := (*(*(struct {
32366                                 Texture
32367                                 Anim  TileAnim
32368                                 Flags TileFlags
32369
32370                                 //mt:if %s.Flags&TileColor != 0
32371                                 R, G, B uint8
32372
32373                                 //mt:if %s.Flags&TileScale != 0
32374                                 Scale uint8
32375
32376                                 //mt:if %s.Flags&TileAlign != 0
32377                                 Align AlignType
32378                         }))(obj)).B
32379                         write8(w, uint8(x))
32380                 }
32381         }
32382         if (*(*(struct {
32383                 Texture
32384                 Anim  TileAnim
32385                 Flags TileFlags
32386
32387                 //mt:if %s.Flags&TileColor != 0
32388                 R, G, B uint8
32389
32390                 //mt:if %s.Flags&TileScale != 0
32391                 Scale uint8
32392
32393                 //mt:if %s.Flags&TileAlign != 0
32394                 Align AlignType
32395         }))(obj)).Flags&TileScale != 0 {
32396                 {
32397                         x := (*(*(struct {
32398                                 Texture
32399                                 Anim  TileAnim
32400                                 Flags TileFlags
32401
32402                                 //mt:if %s.Flags&TileColor != 0
32403                                 R, G, B uint8
32404
32405                                 //mt:if %s.Flags&TileScale != 0
32406                                 Scale uint8
32407
32408                                 //mt:if %s.Flags&TileAlign != 0
32409                                 Align AlignType
32410                         }))(obj)).Scale
32411                         write8(w, uint8(x))
32412                 }
32413         }
32414         if (*(*(struct {
32415                 Texture
32416                 Anim  TileAnim
32417                 Flags TileFlags
32418
32419                 //mt:if %s.Flags&TileColor != 0
32420                 R, G, B uint8
32421
32422                 //mt:if %s.Flags&TileScale != 0
32423                 Scale uint8
32424
32425                 //mt:if %s.Flags&TileAlign != 0
32426                 Align AlignType
32427         }))(obj)).Flags&TileAlign != 0 {
32428                 if err := pcall(func() {
32429                         ((*(*(struct {
32430                                 Texture
32431                                 Anim  TileAnim
32432                                 Flags TileFlags
32433
32434                                 //mt:if %s.Flags&TileColor != 0
32435                                 R, G, B uint8
32436
32437                                 //mt:if %s.Flags&TileScale != 0
32438                                 Scale uint8
32439
32440                                 //mt:if %s.Flags&TileAlign != 0
32441                                 Align AlignType
32442                         }))(obj)).Align).serialize(w)
32443                 }); err != nil {
32444                         if err == io.EOF {
32445                                 chk(io.EOF)
32446                         }
32447                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
32448                 }
32449         }
32450 }
32451
32452 func (obj *TileDef) deserialize(r io.Reader) {
32453         {
32454                 var local373 uint8
32455                 local374 := uint8(6)
32456                 {
32457                         p := &local373
32458                         *p = read8(r)
32459                 }
32460                 if local373 != local374 {
32461                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local373))
32462                 }
32463         }
32464         if err := pcall(func() {
32465                 ((*(*(struct {
32466                         Texture
32467                         Anim  TileAnim
32468                         Flags TileFlags
32469
32470                         //mt:if %s.Flags&TileColor != 0
32471                         R, G, B uint8
32472
32473                         //mt:if %s.Flags&TileScale != 0
32474                         Scale uint8
32475
32476                         //mt:if %s.Flags&TileAlign != 0
32477                         Align AlignType
32478                 }))(obj)).Texture).deserialize(r)
32479         }); err != nil {
32480                 if err == io.EOF {
32481                         chk(io.EOF)
32482                 }
32483                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
32484         }
32485         if err := pcall(func() {
32486                 ((*(*(struct {
32487                         Texture
32488                         Anim  TileAnim
32489                         Flags TileFlags
32490
32491                         //mt:if %s.Flags&TileColor != 0
32492                         R, G, B uint8
32493
32494                         //mt:if %s.Flags&TileScale != 0
32495                         Scale uint8
32496
32497                         //mt:if %s.Flags&TileAlign != 0
32498                         Align AlignType
32499                 }))(obj)).Anim).deserialize(r)
32500         }); err != nil {
32501                 if err == io.EOF {
32502                         chk(io.EOF)
32503                 }
32504                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
32505         }
32506         if err := pcall(func() {
32507                 ((*(*(struct {
32508                         Texture
32509                         Anim  TileAnim
32510                         Flags TileFlags
32511
32512                         //mt:if %s.Flags&TileColor != 0
32513                         R, G, B uint8
32514
32515                         //mt:if %s.Flags&TileScale != 0
32516                         Scale uint8
32517
32518                         //mt:if %s.Flags&TileAlign != 0
32519                         Align AlignType
32520                 }))(obj)).Flags).deserialize(r)
32521         }); err != nil {
32522                 if err == io.EOF {
32523                         chk(io.EOF)
32524                 }
32525                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
32526         }
32527         if (*(*(struct {
32528                 Texture
32529                 Anim  TileAnim
32530                 Flags TileFlags
32531
32532                 //mt:if %s.Flags&TileColor != 0
32533                 R, G, B uint8
32534
32535                 //mt:if %s.Flags&TileScale != 0
32536                 Scale uint8
32537
32538                 //mt:if %s.Flags&TileAlign != 0
32539                 Align AlignType
32540         }))(obj)).Flags&TileColor != 0 {
32541                 {
32542                         p := &(*(*(struct {
32543                                 Texture
32544                                 Anim  TileAnim
32545                                 Flags TileFlags
32546
32547                                 //mt:if %s.Flags&TileColor != 0
32548                                 R, G, B uint8
32549
32550                                 //mt:if %s.Flags&TileScale != 0
32551                                 Scale uint8
32552
32553                                 //mt:if %s.Flags&TileAlign != 0
32554                                 Align AlignType
32555                         }))(obj)).R
32556                         *p = read8(r)
32557                 }
32558                 {
32559                         p := &(*(*(struct {
32560                                 Texture
32561                                 Anim  TileAnim
32562                                 Flags TileFlags
32563
32564                                 //mt:if %s.Flags&TileColor != 0
32565                                 R, G, B uint8
32566
32567                                 //mt:if %s.Flags&TileScale != 0
32568                                 Scale uint8
32569
32570                                 //mt:if %s.Flags&TileAlign != 0
32571                                 Align AlignType
32572                         }))(obj)).G
32573                         *p = read8(r)
32574                 }
32575                 {
32576                         p := &(*(*(struct {
32577                                 Texture
32578                                 Anim  TileAnim
32579                                 Flags TileFlags
32580
32581                                 //mt:if %s.Flags&TileColor != 0
32582                                 R, G, B uint8
32583
32584                                 //mt:if %s.Flags&TileScale != 0
32585                                 Scale uint8
32586
32587                                 //mt:if %s.Flags&TileAlign != 0
32588                                 Align AlignType
32589                         }))(obj)).B
32590                         *p = read8(r)
32591                 }
32592         }
32593         if (*(*(struct {
32594                 Texture
32595                 Anim  TileAnim
32596                 Flags TileFlags
32597
32598                 //mt:if %s.Flags&TileColor != 0
32599                 R, G, B uint8
32600
32601                 //mt:if %s.Flags&TileScale != 0
32602                 Scale uint8
32603
32604                 //mt:if %s.Flags&TileAlign != 0
32605                 Align AlignType
32606         }))(obj)).Flags&TileScale != 0 {
32607                 {
32608                         p := &(*(*(struct {
32609                                 Texture
32610                                 Anim  TileAnim
32611                                 Flags TileFlags
32612
32613                                 //mt:if %s.Flags&TileColor != 0
32614                                 R, G, B uint8
32615
32616                                 //mt:if %s.Flags&TileScale != 0
32617                                 Scale uint8
32618
32619                                 //mt:if %s.Flags&TileAlign != 0
32620                                 Align AlignType
32621                         }))(obj)).Scale
32622                         *p = read8(r)
32623                 }
32624         }
32625         if (*(*(struct {
32626                 Texture
32627                 Anim  TileAnim
32628                 Flags TileFlags
32629
32630                 //mt:if %s.Flags&TileColor != 0
32631                 R, G, B uint8
32632
32633                 //mt:if %s.Flags&TileScale != 0
32634                 Scale uint8
32635
32636                 //mt:if %s.Flags&TileAlign != 0
32637                 Align AlignType
32638         }))(obj)).Flags&TileAlign != 0 {
32639                 if err := pcall(func() {
32640                         ((*(*(struct {
32641                                 Texture
32642                                 Anim  TileAnim
32643                                 Flags TileFlags
32644
32645                                 //mt:if %s.Flags&TileColor != 0
32646                                 R, G, B uint8
32647
32648                                 //mt:if %s.Flags&TileScale != 0
32649                                 Scale uint8
32650
32651                                 //mt:if %s.Flags&TileAlign != 0
32652                                 Align AlignType
32653                         }))(obj)).Align).deserialize(r)
32654                 }); err != nil {
32655                         if err == io.EOF {
32656                                 chk(io.EOF)
32657                         }
32658                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
32659                 }
32660         }
32661 }
32662
32663 func (obj *WaveType) serialize(w io.Writer) {
32664         {
32665                 x := *(*(uint8))(obj)
32666                 write8(w, uint8(x))
32667         }
32668 }
32669
32670 func (obj *WaveType) deserialize(r io.Reader) {
32671         {
32672                 p := &*(*(uint8))(obj)
32673                 *p = read8(r)
32674         }
32675 }
32676
32677 func (obj *LiquidType) serialize(w io.Writer) {
32678         {
32679                 x := *(*(uint8))(obj)
32680                 write8(w, uint8(x))
32681         }
32682 }
32683
32684 func (obj *LiquidType) deserialize(r io.Reader) {
32685         {
32686                 p := &*(*(uint8))(obj)
32687                 *p = read8(r)
32688         }
32689 }
32690
32691 func (obj *NodeBox) serialize(w io.Writer) {
32692         {
32693                 local375 := uint8(6)
32694                 {
32695                         x := local375
32696                         write8(w, uint8(x))
32697                 }
32698         }
32699         if err := pcall(func() {
32700                 ((*(*(struct {
32701                         Type NodeBoxType
32702
32703                         //mt:if %s.Type == MountedBox
32704                         WallTop, WallBot, WallSides Box
32705
32706                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32707                         Fixed []Box
32708
32709                         //mt:if %s.Type == ConnectedBox
32710                         ConnDirs, DiscoDirs  DirBoxes
32711                         DiscoAll, DiscoSides []Box
32712                 }))(obj)).Type).serialize(w)
32713         }); err != nil {
32714                 if err == io.EOF {
32715                         chk(io.EOF)
32716                 }
32717                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
32718         }
32719         if !((*(*(struct {
32720                 Type NodeBoxType
32721
32722                 //mt:if %s.Type == MountedBox
32723                 WallTop, WallBot, WallSides Box
32724
32725                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32726                 Fixed []Box
32727
32728                 //mt:if %s.Type == ConnectedBox
32729                 ConnDirs, DiscoDirs  DirBoxes
32730                 DiscoAll, DiscoSides []Box
32731         }))(obj)).Type < maxBox) {
32732                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32733         }
32734         if (*(*(struct {
32735                 Type NodeBoxType
32736
32737                 //mt:if %s.Type == MountedBox
32738                 WallTop, WallBot, WallSides Box
32739
32740                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32741                 Fixed []Box
32742
32743                 //mt:if %s.Type == ConnectedBox
32744                 ConnDirs, DiscoDirs  DirBoxes
32745                 DiscoAll, DiscoSides []Box
32746         }))(obj)).Type == MountedBox {
32747                 if err := pcall(func() {
32748                         ((*(*(struct {
32749                                 Type NodeBoxType
32750
32751                                 //mt:if %s.Type == MountedBox
32752                                 WallTop, WallBot, WallSides Box
32753
32754                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32755                                 Fixed []Box
32756
32757                                 //mt:if %s.Type == ConnectedBox
32758                                 ConnDirs, DiscoDirs  DirBoxes
32759                                 DiscoAll, DiscoSides []Box
32760                         }))(obj)).WallTop).serialize(w)
32761                 }); err != nil {
32762                         if err == io.EOF {
32763                                 chk(io.EOF)
32764                         }
32765                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
32766                 }
32767                 if err := pcall(func() {
32768                         ((*(*(struct {
32769                                 Type NodeBoxType
32770
32771                                 //mt:if %s.Type == MountedBox
32772                                 WallTop, WallBot, WallSides Box
32773
32774                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32775                                 Fixed []Box
32776
32777                                 //mt:if %s.Type == ConnectedBox
32778                                 ConnDirs, DiscoDirs  DirBoxes
32779                                 DiscoAll, DiscoSides []Box
32780                         }))(obj)).WallBot).serialize(w)
32781                 }); err != nil {
32782                         if err == io.EOF {
32783                                 chk(io.EOF)
32784                         }
32785                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
32786                 }
32787                 if err := pcall(func() {
32788                         ((*(*(struct {
32789                                 Type NodeBoxType
32790
32791                                 //mt:if %s.Type == MountedBox
32792                                 WallTop, WallBot, WallSides Box
32793
32794                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32795                                 Fixed []Box
32796
32797                                 //mt:if %s.Type == ConnectedBox
32798                                 ConnDirs, DiscoDirs  DirBoxes
32799                                 DiscoAll, DiscoSides []Box
32800                         }))(obj)).WallSides).serialize(w)
32801                 }); err != nil {
32802                         if err == io.EOF {
32803                                 chk(io.EOF)
32804                         }
32805                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
32806                 }
32807         }
32808         if t := (*(*(struct {
32809                 Type NodeBoxType
32810
32811                 //mt:if %s.Type == MountedBox
32812                 WallTop, WallBot, WallSides Box
32813
32814                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32815                 Fixed []Box
32816
32817                 //mt:if %s.Type == ConnectedBox
32818                 ConnDirs, DiscoDirs  DirBoxes
32819                 DiscoAll, DiscoSides []Box
32820         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32821                 if len(((*(*(struct {
32822                         Type NodeBoxType
32823
32824                         //mt:if %s.Type == MountedBox
32825                         WallTop, WallBot, WallSides Box
32826
32827                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32828                         Fixed []Box
32829
32830                         //mt:if %s.Type == ConnectedBox
32831                         ConnDirs, DiscoDirs  DirBoxes
32832                         DiscoAll, DiscoSides []Box
32833                 }))(obj)).Fixed)) > math.MaxUint16 {
32834                         chk(ErrTooLong)
32835                 }
32836                 {
32837                         x := uint16(len(((*(*(struct {
32838                                 Type NodeBoxType
32839
32840                                 //mt:if %s.Type == MountedBox
32841                                 WallTop, WallBot, WallSides Box
32842
32843                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32844                                 Fixed []Box
32845
32846                                 //mt:if %s.Type == ConnectedBox
32847                                 ConnDirs, DiscoDirs  DirBoxes
32848                                 DiscoAll, DiscoSides []Box
32849                         }))(obj)).Fixed)))
32850                         write16(w, uint16(x))
32851                 }
32852                 for local376 := range (*(*(struct {
32853                         Type NodeBoxType
32854
32855                         //mt:if %s.Type == MountedBox
32856                         WallTop, WallBot, WallSides Box
32857
32858                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32859                         Fixed []Box
32860
32861                         //mt:if %s.Type == ConnectedBox
32862                         ConnDirs, DiscoDirs  DirBoxes
32863                         DiscoAll, DiscoSides []Box
32864                 }))(obj)).Fixed {
32865                         if err := pcall(func() {
32866                                 (((*(*(struct {
32867                                         Type NodeBoxType
32868
32869                                         //mt:if %s.Type == MountedBox
32870                                         WallTop, WallBot, WallSides Box
32871
32872                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32873                                         Fixed []Box
32874
32875                                         //mt:if %s.Type == ConnectedBox
32876                                         ConnDirs, DiscoDirs  DirBoxes
32877                                         DiscoAll, DiscoSides []Box
32878                                 }))(obj)).Fixed)[local376]).serialize(w)
32879                         }); err != nil {
32880                                 if err == io.EOF {
32881                                         chk(io.EOF)
32882                                 }
32883                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
32884                         }
32885                 }
32886         }
32887         if (*(*(struct {
32888                 Type NodeBoxType
32889
32890                 //mt:if %s.Type == MountedBox
32891                 WallTop, WallBot, WallSides Box
32892
32893                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32894                 Fixed []Box
32895
32896                 //mt:if %s.Type == ConnectedBox
32897                 ConnDirs, DiscoDirs  DirBoxes
32898                 DiscoAll, DiscoSides []Box
32899         }))(obj)).Type == ConnectedBox {
32900                 if err := pcall(func() {
32901                         ((*(*(struct {
32902                                 Type NodeBoxType
32903
32904                                 //mt:if %s.Type == MountedBox
32905                                 WallTop, WallBot, WallSides Box
32906
32907                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32908                                 Fixed []Box
32909
32910                                 //mt:if %s.Type == ConnectedBox
32911                                 ConnDirs, DiscoDirs  DirBoxes
32912                                 DiscoAll, DiscoSides []Box
32913                         }))(obj)).ConnDirs).serialize(w)
32914                 }); err != nil {
32915                         if err == io.EOF {
32916                                 chk(io.EOF)
32917                         }
32918                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
32919                 }
32920                 if err := pcall(func() {
32921                         ((*(*(struct {
32922                                 Type NodeBoxType
32923
32924                                 //mt:if %s.Type == MountedBox
32925                                 WallTop, WallBot, WallSides Box
32926
32927                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32928                                 Fixed []Box
32929
32930                                 //mt:if %s.Type == ConnectedBox
32931                                 ConnDirs, DiscoDirs  DirBoxes
32932                                 DiscoAll, DiscoSides []Box
32933                         }))(obj)).DiscoDirs).serialize(w)
32934                 }); err != nil {
32935                         if err == io.EOF {
32936                                 chk(io.EOF)
32937                         }
32938                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
32939                 }
32940                 if len(((*(*(struct {
32941                         Type NodeBoxType
32942
32943                         //mt:if %s.Type == MountedBox
32944                         WallTop, WallBot, WallSides Box
32945
32946                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32947                         Fixed []Box
32948
32949                         //mt:if %s.Type == ConnectedBox
32950                         ConnDirs, DiscoDirs  DirBoxes
32951                         DiscoAll, DiscoSides []Box
32952                 }))(obj)).DiscoAll)) > math.MaxUint16 {
32953                         chk(ErrTooLong)
32954                 }
32955                 {
32956                         x := uint16(len(((*(*(struct {
32957                                 Type NodeBoxType
32958
32959                                 //mt:if %s.Type == MountedBox
32960                                 WallTop, WallBot, WallSides Box
32961
32962                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32963                                 Fixed []Box
32964
32965                                 //mt:if %s.Type == ConnectedBox
32966                                 ConnDirs, DiscoDirs  DirBoxes
32967                                 DiscoAll, DiscoSides []Box
32968                         }))(obj)).DiscoAll)))
32969                         write16(w, uint16(x))
32970                 }
32971                 for local377 := range (*(*(struct {
32972                         Type NodeBoxType
32973
32974                         //mt:if %s.Type == MountedBox
32975                         WallTop, WallBot, WallSides Box
32976
32977                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32978                         Fixed []Box
32979
32980                         //mt:if %s.Type == ConnectedBox
32981                         ConnDirs, DiscoDirs  DirBoxes
32982                         DiscoAll, DiscoSides []Box
32983                 }))(obj)).DiscoAll {
32984                         if err := pcall(func() {
32985                                 (((*(*(struct {
32986                                         Type NodeBoxType
32987
32988                                         //mt:if %s.Type == MountedBox
32989                                         WallTop, WallBot, WallSides Box
32990
32991                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32992                                         Fixed []Box
32993
32994                                         //mt:if %s.Type == ConnectedBox
32995                                         ConnDirs, DiscoDirs  DirBoxes
32996                                         DiscoAll, DiscoSides []Box
32997                                 }))(obj)).DiscoAll)[local377]).serialize(w)
32998                         }); err != nil {
32999                                 if err == io.EOF {
33000                                         chk(io.EOF)
33001                                 }
33002                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33003                         }
33004                 }
33005                 if len(((*(*(struct {
33006                         Type NodeBoxType
33007
33008                         //mt:if %s.Type == MountedBox
33009                         WallTop, WallBot, WallSides Box
33010
33011                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33012                         Fixed []Box
33013
33014                         //mt:if %s.Type == ConnectedBox
33015                         ConnDirs, DiscoDirs  DirBoxes
33016                         DiscoAll, DiscoSides []Box
33017                 }))(obj)).DiscoSides)) > math.MaxUint16 {
33018                         chk(ErrTooLong)
33019                 }
33020                 {
33021                         x := uint16(len(((*(*(struct {
33022                                 Type NodeBoxType
33023
33024                                 //mt:if %s.Type == MountedBox
33025                                 WallTop, WallBot, WallSides Box
33026
33027                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33028                                 Fixed []Box
33029
33030                                 //mt:if %s.Type == ConnectedBox
33031                                 ConnDirs, DiscoDirs  DirBoxes
33032                                 DiscoAll, DiscoSides []Box
33033                         }))(obj)).DiscoSides)))
33034                         write16(w, uint16(x))
33035                 }
33036                 for local378 := range (*(*(struct {
33037                         Type NodeBoxType
33038
33039                         //mt:if %s.Type == MountedBox
33040                         WallTop, WallBot, WallSides Box
33041
33042                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33043                         Fixed []Box
33044
33045                         //mt:if %s.Type == ConnectedBox
33046                         ConnDirs, DiscoDirs  DirBoxes
33047                         DiscoAll, DiscoSides []Box
33048                 }))(obj)).DiscoSides {
33049                         if err := pcall(func() {
33050                                 (((*(*(struct {
33051                                         Type NodeBoxType
33052
33053                                         //mt:if %s.Type == MountedBox
33054                                         WallTop, WallBot, WallSides Box
33055
33056                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33057                                         Fixed []Box
33058
33059                                         //mt:if %s.Type == ConnectedBox
33060                                         ConnDirs, DiscoDirs  DirBoxes
33061                                         DiscoAll, DiscoSides []Box
33062                                 }))(obj)).DiscoSides)[local378]).serialize(w)
33063                         }); err != nil {
33064                                 if err == io.EOF {
33065                                         chk(io.EOF)
33066                                 }
33067                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33068                         }
33069                 }
33070         }
33071 }
33072
33073 func (obj *NodeBox) deserialize(r io.Reader) {
33074         {
33075                 var local379 uint8
33076                 local380 := uint8(6)
33077                 {
33078                         p := &local379
33079                         *p = read8(r)
33080                 }
33081                 if local379 != local380 {
33082                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local379))
33083                 }
33084         }
33085         if err := pcall(func() {
33086                 ((*(*(struct {
33087                         Type NodeBoxType
33088
33089                         //mt:if %s.Type == MountedBox
33090                         WallTop, WallBot, WallSides Box
33091
33092                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33093                         Fixed []Box
33094
33095                         //mt:if %s.Type == ConnectedBox
33096                         ConnDirs, DiscoDirs  DirBoxes
33097                         DiscoAll, DiscoSides []Box
33098                 }))(obj)).Type).deserialize(r)
33099         }); err != nil {
33100                 if err == io.EOF {
33101                         chk(io.EOF)
33102                 }
33103                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
33104         }
33105         if !((*(*(struct {
33106                 Type NodeBoxType
33107
33108                 //mt:if %s.Type == MountedBox
33109                 WallTop, WallBot, WallSides Box
33110
33111                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33112                 Fixed []Box
33113
33114                 //mt:if %s.Type == ConnectedBox
33115                 ConnDirs, DiscoDirs  DirBoxes
33116                 DiscoAll, DiscoSides []Box
33117         }))(obj)).Type < maxBox) {
33118                 chk(errors.New("assertion failed: %s.Type < maxBox"))
33119         }
33120         if (*(*(struct {
33121                 Type NodeBoxType
33122
33123                 //mt:if %s.Type == MountedBox
33124                 WallTop, WallBot, WallSides Box
33125
33126                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33127                 Fixed []Box
33128
33129                 //mt:if %s.Type == ConnectedBox
33130                 ConnDirs, DiscoDirs  DirBoxes
33131                 DiscoAll, DiscoSides []Box
33132         }))(obj)).Type == MountedBox {
33133                 if err := pcall(func() {
33134                         ((*(*(struct {
33135                                 Type NodeBoxType
33136
33137                                 //mt:if %s.Type == MountedBox
33138                                 WallTop, WallBot, WallSides Box
33139
33140                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33141                                 Fixed []Box
33142
33143                                 //mt:if %s.Type == ConnectedBox
33144                                 ConnDirs, DiscoDirs  DirBoxes
33145                                 DiscoAll, DiscoSides []Box
33146                         }))(obj)).WallTop).deserialize(r)
33147                 }); err != nil {
33148                         if err == io.EOF {
33149                                 chk(io.EOF)
33150                         }
33151                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33152                 }
33153                 if err := pcall(func() {
33154                         ((*(*(struct {
33155                                 Type NodeBoxType
33156
33157                                 //mt:if %s.Type == MountedBox
33158                                 WallTop, WallBot, WallSides Box
33159
33160                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33161                                 Fixed []Box
33162
33163                                 //mt:if %s.Type == ConnectedBox
33164                                 ConnDirs, DiscoDirs  DirBoxes
33165                                 DiscoAll, DiscoSides []Box
33166                         }))(obj)).WallBot).deserialize(r)
33167                 }); err != nil {
33168                         if err == io.EOF {
33169                                 chk(io.EOF)
33170                         }
33171                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33172                 }
33173                 if err := pcall(func() {
33174                         ((*(*(struct {
33175                                 Type NodeBoxType
33176
33177                                 //mt:if %s.Type == MountedBox
33178                                 WallTop, WallBot, WallSides Box
33179
33180                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33181                                 Fixed []Box
33182
33183                                 //mt:if %s.Type == ConnectedBox
33184                                 ConnDirs, DiscoDirs  DirBoxes
33185                                 DiscoAll, DiscoSides []Box
33186                         }))(obj)).WallSides).deserialize(r)
33187                 }); err != nil {
33188                         if err == io.EOF {
33189                                 chk(io.EOF)
33190                         }
33191                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33192                 }
33193         }
33194         if t := (*(*(struct {
33195                 Type NodeBoxType
33196
33197                 //mt:if %s.Type == MountedBox
33198                 WallTop, WallBot, WallSides Box
33199
33200                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33201                 Fixed []Box
33202
33203                 //mt:if %s.Type == ConnectedBox
33204                 ConnDirs, DiscoDirs  DirBoxes
33205                 DiscoAll, DiscoSides []Box
33206         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
33207                 var local381 uint16
33208                 {
33209                         p := &local381
33210                         *p = read16(r)
33211                 }
33212                 ((*(*(struct {
33213                         Type NodeBoxType
33214
33215                         //mt:if %s.Type == MountedBox
33216                         WallTop, WallBot, WallSides Box
33217
33218                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33219                         Fixed []Box
33220
33221                         //mt:if %s.Type == ConnectedBox
33222                         ConnDirs, DiscoDirs  DirBoxes
33223                         DiscoAll, DiscoSides []Box
33224                 }))(obj)).Fixed) = make([]Box, local381)
33225                 for local382 := range (*(*(struct {
33226                         Type NodeBoxType
33227
33228                         //mt:if %s.Type == MountedBox
33229                         WallTop, WallBot, WallSides Box
33230
33231                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33232                         Fixed []Box
33233
33234                         //mt:if %s.Type == ConnectedBox
33235                         ConnDirs, DiscoDirs  DirBoxes
33236                         DiscoAll, DiscoSides []Box
33237                 }))(obj)).Fixed {
33238                         if err := pcall(func() {
33239                                 (((*(*(struct {
33240                                         Type NodeBoxType
33241
33242                                         //mt:if %s.Type == MountedBox
33243                                         WallTop, WallBot, WallSides Box
33244
33245                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33246                                         Fixed []Box
33247
33248                                         //mt:if %s.Type == ConnectedBox
33249                                         ConnDirs, DiscoDirs  DirBoxes
33250                                         DiscoAll, DiscoSides []Box
33251                                 }))(obj)).Fixed)[local382]).deserialize(r)
33252                         }); err != nil {
33253                                 if err == io.EOF {
33254                                         chk(io.EOF)
33255                                 }
33256                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33257                         }
33258                 }
33259         }
33260         if (*(*(struct {
33261                 Type NodeBoxType
33262
33263                 //mt:if %s.Type == MountedBox
33264                 WallTop, WallBot, WallSides Box
33265
33266                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33267                 Fixed []Box
33268
33269                 //mt:if %s.Type == ConnectedBox
33270                 ConnDirs, DiscoDirs  DirBoxes
33271                 DiscoAll, DiscoSides []Box
33272         }))(obj)).Type == ConnectedBox {
33273                 if err := pcall(func() {
33274                         ((*(*(struct {
33275                                 Type NodeBoxType
33276
33277                                 //mt:if %s.Type == MountedBox
33278                                 WallTop, WallBot, WallSides Box
33279
33280                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33281                                 Fixed []Box
33282
33283                                 //mt:if %s.Type == ConnectedBox
33284                                 ConnDirs, DiscoDirs  DirBoxes
33285                                 DiscoAll, DiscoSides []Box
33286                         }))(obj)).ConnDirs).deserialize(r)
33287                 }); err != nil {
33288                         if err == io.EOF {
33289                                 chk(io.EOF)
33290                         }
33291                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33292                 }
33293                 if err := pcall(func() {
33294                         ((*(*(struct {
33295                                 Type NodeBoxType
33296
33297                                 //mt:if %s.Type == MountedBox
33298                                 WallTop, WallBot, WallSides Box
33299
33300                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33301                                 Fixed []Box
33302
33303                                 //mt:if %s.Type == ConnectedBox
33304                                 ConnDirs, DiscoDirs  DirBoxes
33305                                 DiscoAll, DiscoSides []Box
33306                         }))(obj)).DiscoDirs).deserialize(r)
33307                 }); err != nil {
33308                         if err == io.EOF {
33309                                 chk(io.EOF)
33310                         }
33311                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33312                 }
33313                 var local383 uint16
33314                 {
33315                         p := &local383
33316                         *p = read16(r)
33317                 }
33318                 ((*(*(struct {
33319                         Type NodeBoxType
33320
33321                         //mt:if %s.Type == MountedBox
33322                         WallTop, WallBot, WallSides Box
33323
33324                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33325                         Fixed []Box
33326
33327                         //mt:if %s.Type == ConnectedBox
33328                         ConnDirs, DiscoDirs  DirBoxes
33329                         DiscoAll, DiscoSides []Box
33330                 }))(obj)).DiscoAll) = make([]Box, local383)
33331                 for local384 := range (*(*(struct {
33332                         Type NodeBoxType
33333
33334                         //mt:if %s.Type == MountedBox
33335                         WallTop, WallBot, WallSides Box
33336
33337                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33338                         Fixed []Box
33339
33340                         //mt:if %s.Type == ConnectedBox
33341                         ConnDirs, DiscoDirs  DirBoxes
33342                         DiscoAll, DiscoSides []Box
33343                 }))(obj)).DiscoAll {
33344                         if err := pcall(func() {
33345                                 (((*(*(struct {
33346                                         Type NodeBoxType
33347
33348                                         //mt:if %s.Type == MountedBox
33349                                         WallTop, WallBot, WallSides Box
33350
33351                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33352                                         Fixed []Box
33353
33354                                         //mt:if %s.Type == ConnectedBox
33355                                         ConnDirs, DiscoDirs  DirBoxes
33356                                         DiscoAll, DiscoSides []Box
33357                                 }))(obj)).DiscoAll)[local384]).deserialize(r)
33358                         }); err != nil {
33359                                 if err == io.EOF {
33360                                         chk(io.EOF)
33361                                 }
33362                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33363                         }
33364                 }
33365                 var local385 uint16
33366                 {
33367                         p := &local385
33368                         *p = read16(r)
33369                 }
33370                 ((*(*(struct {
33371                         Type NodeBoxType
33372
33373                         //mt:if %s.Type == MountedBox
33374                         WallTop, WallBot, WallSides Box
33375
33376                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33377                         Fixed []Box
33378
33379                         //mt:if %s.Type == ConnectedBox
33380                         ConnDirs, DiscoDirs  DirBoxes
33381                         DiscoAll, DiscoSides []Box
33382                 }))(obj)).DiscoSides) = make([]Box, local385)
33383                 for local386 := range (*(*(struct {
33384                         Type NodeBoxType
33385
33386                         //mt:if %s.Type == MountedBox
33387                         WallTop, WallBot, WallSides Box
33388
33389                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33390                         Fixed []Box
33391
33392                         //mt:if %s.Type == ConnectedBox
33393                         ConnDirs, DiscoDirs  DirBoxes
33394                         DiscoAll, DiscoSides []Box
33395                 }))(obj)).DiscoSides {
33396                         if err := pcall(func() {
33397                                 (((*(*(struct {
33398                                         Type NodeBoxType
33399
33400                                         //mt:if %s.Type == MountedBox
33401                                         WallTop, WallBot, WallSides Box
33402
33403                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33404                                         Fixed []Box
33405
33406                                         //mt:if %s.Type == ConnectedBox
33407                                         ConnDirs, DiscoDirs  DirBoxes
33408                                         DiscoAll, DiscoSides []Box
33409                                 }))(obj)).DiscoSides)[local386]).deserialize(r)
33410                         }); err != nil {
33411                                 if err == io.EOF {
33412                                         chk(io.EOF)
33413                                 }
33414                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33415                         }
33416                 }
33417         }
33418 }
33419
33420 func (obj *SoundDef) serialize(w io.Writer) {
33421         if len(([]byte((*(*(struct {
33422                 Name              string
33423                 Gain, Pitch, Fade float32
33424         }))(obj)).Name))) > math.MaxUint16 {
33425                 chk(ErrTooLong)
33426         }
33427         {
33428                 x := uint16(len(([]byte((*(*(struct {
33429                         Name              string
33430                         Gain, Pitch, Fade float32
33431                 }))(obj)).Name))))
33432                 write16(w, uint16(x))
33433         }
33434         {
33435                 _, err := w.Write(([]byte((*(*(struct {
33436                         Name              string
33437                         Gain, Pitch, Fade float32
33438                 }))(obj)).Name))[:])
33439                 chk(err)
33440         }
33441         {
33442                 x := (*(*(struct {
33443                         Name              string
33444                         Gain, Pitch, Fade float32
33445                 }))(obj)).Gain
33446                 write32(w, math.Float32bits(x))
33447         }
33448         {
33449                 x := (*(*(struct {
33450                         Name              string
33451                         Gain, Pitch, Fade float32
33452                 }))(obj)).Pitch
33453                 write32(w, math.Float32bits(x))
33454         }
33455         {
33456                 x := (*(*(struct {
33457                         Name              string
33458                         Gain, Pitch, Fade float32
33459                 }))(obj)).Fade
33460                 write32(w, math.Float32bits(x))
33461         }
33462 }
33463
33464 func (obj *SoundDef) deserialize(r io.Reader) {
33465         var local387 []uint8
33466         var local388 uint16
33467         {
33468                 p := &local388
33469                 *p = read16(r)
33470         }
33471         (local387) = make([]uint8, local388)
33472         {
33473                 _, err := io.ReadFull(r, (local387)[:])
33474                 chk(err)
33475         }
33476         ((*(*(struct {
33477                 Name              string
33478                 Gain, Pitch, Fade float32
33479         }))(obj)).Name) = string(local387)
33480         {
33481                 p := &(*(*(struct {
33482                         Name              string
33483                         Gain, Pitch, Fade float32
33484                 }))(obj)).Gain
33485                 *p = math.Float32frombits(read32(r))
33486         }
33487         {
33488                 p := &(*(*(struct {
33489                         Name              string
33490                         Gain, Pitch, Fade float32
33491                 }))(obj)).Pitch
33492                 *p = math.Float32frombits(read32(r))
33493         }
33494         {
33495                 p := &(*(*(struct {
33496                         Name              string
33497                         Gain, Pitch, Fade float32
33498                 }))(obj)).Fade
33499                 *p = math.Float32frombits(read32(r))
33500         }
33501 }
33502
33503 func (obj *AlphaUse) serialize(w io.Writer) {
33504         {
33505                 x := *(*(uint8))(obj)
33506                 write8(w, uint8(x))
33507         }
33508 }
33509
33510 func (obj *AlphaUse) deserialize(r io.Reader) {
33511         {
33512                 p := &*(*(uint8))(obj)
33513                 *p = read8(r)
33514         }
33515 }
33516
33517 func (obj *Keys) serialize(w io.Writer) {
33518         {
33519                 x := *(*(uint32))(obj)
33520                 write32(w, uint32(x))
33521         }
33522 }
33523
33524 func (obj *Keys) deserialize(r io.Reader) {
33525         {
33526                 p := &*(*(uint32))(obj)
33527                 *p = read32(r)
33528         }
33529 }
33530
33531 func (obj *MapBlkFlags) serialize(w io.Writer) {
33532         {
33533                 x := *(*(uint8))(obj)
33534                 write8(w, uint8(x))
33535         }
33536 }
33537
33538 func (obj *MapBlkFlags) deserialize(r io.Reader) {
33539         {
33540                 p := &*(*(uint8))(obj)
33541                 *p = read8(r)
33542         }
33543 }
33544
33545 func (obj *LitFromBlks) serialize(w io.Writer) {
33546         {
33547                 x := *(*(uint16))(obj)
33548                 write16(w, uint16(x))
33549         }
33550 }
33551
33552 func (obj *LitFromBlks) deserialize(r io.Reader) {
33553         {
33554                 p := &*(*(uint16))(obj)
33555                 *p = read16(r)
33556         }
33557 }
33558
33559 func (obj *AOInitData) serialize(w io.Writer) {
33560         {
33561                 local389 := uint8(1)
33562                 {
33563                         x := local389
33564                         write8(w, uint8(x))
33565                 }
33566         }
33567         if len(([]byte((*(*(struct {
33568
33569                 // For players.
33570                 Name     string
33571                 IsPlayer bool
33572
33573                 ID AOID
33574
33575                 Pos
33576                 Rot [3]float32
33577
33578                 HP uint16
33579
33580                 // See (de)serialize.fmt.
33581                 Msgs []AOMsg
33582         }))(obj)).Name))) > math.MaxUint16 {
33583                 chk(ErrTooLong)
33584         }
33585         {
33586                 x := uint16(len(([]byte((*(*(struct {
33587
33588                         // For players.
33589                         Name     string
33590                         IsPlayer bool
33591
33592                         ID AOID
33593
33594                         Pos
33595                         Rot [3]float32
33596
33597                         HP uint16
33598
33599                         // See (de)serialize.fmt.
33600                         Msgs []AOMsg
33601                 }))(obj)).Name))))
33602                 write16(w, uint16(x))
33603         }
33604         {
33605                 _, err := w.Write(([]byte((*(*(struct {
33606
33607                         // For players.
33608                         Name     string
33609                         IsPlayer bool
33610
33611                         ID AOID
33612
33613                         Pos
33614                         Rot [3]float32
33615
33616                         HP uint16
33617
33618                         // See (de)serialize.fmt.
33619                         Msgs []AOMsg
33620                 }))(obj)).Name))[:])
33621                 chk(err)
33622         }
33623         {
33624                 x := (*(*(struct {
33625
33626                         // For players.
33627                         Name     string
33628                         IsPlayer bool
33629
33630                         ID AOID
33631
33632                         Pos
33633                         Rot [3]float32
33634
33635                         HP uint16
33636
33637                         // See (de)serialize.fmt.
33638                         Msgs []AOMsg
33639                 }))(obj)).IsPlayer
33640                 if x {
33641                         write8(w, 1)
33642                 } else {
33643                         write8(w, 0)
33644                 }
33645         }
33646         if err := pcall(func() {
33647                 ((*(*(struct {
33648
33649                         // For players.
33650                         Name     string
33651                         IsPlayer bool
33652
33653                         ID AOID
33654
33655                         Pos
33656                         Rot [3]float32
33657
33658                         HP uint16
33659
33660                         // See (de)serialize.fmt.
33661                         Msgs []AOMsg
33662                 }))(obj)).ID).serialize(w)
33663         }); err != nil {
33664                 if err == io.EOF {
33665                         chk(io.EOF)
33666                 }
33667                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
33668         }
33669         if err := pcall(func() {
33670                 ((*(*(struct {
33671
33672                         // For players.
33673                         Name     string
33674                         IsPlayer bool
33675
33676                         ID AOID
33677
33678                         Pos
33679                         Rot [3]float32
33680
33681                         HP uint16
33682
33683                         // See (de)serialize.fmt.
33684                         Msgs []AOMsg
33685                 }))(obj)).Pos).serialize(w)
33686         }); err != nil {
33687                 if err == io.EOF {
33688                         chk(io.EOF)
33689                 }
33690                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
33691         }
33692         for local390 := range (*(*(struct {
33693
33694                 // For players.
33695                 Name     string
33696                 IsPlayer bool
33697
33698                 ID AOID
33699
33700                 Pos
33701                 Rot [3]float32
33702
33703                 HP uint16
33704
33705                 // See (de)serialize.fmt.
33706                 Msgs []AOMsg
33707         }))(obj)).Rot {
33708                 {
33709                         x := ((*(*(struct {
33710
33711                                 // For players.
33712                                 Name     string
33713                                 IsPlayer bool
33714
33715                                 ID AOID
33716
33717                                 Pos
33718                                 Rot [3]float32
33719
33720                                 HP uint16
33721
33722                                 // See (de)serialize.fmt.
33723                                 Msgs []AOMsg
33724                         }))(obj)).Rot)[local390]
33725                         write32(w, math.Float32bits(x))
33726                 }
33727         }
33728         {
33729                 x := (*(*(struct {
33730
33731                         // For players.
33732                         Name     string
33733                         IsPlayer bool
33734
33735                         ID AOID
33736
33737                         Pos
33738                         Rot [3]float32
33739
33740                         HP uint16
33741
33742                         // See (de)serialize.fmt.
33743                         Msgs []AOMsg
33744                 }))(obj)).HP
33745                 write16(w, uint16(x))
33746         }
33747         {
33748                 x := (*(*(struct {
33749
33750                         // For players.
33751                         Name     string
33752                         IsPlayer bool
33753
33754                         ID AOID
33755
33756                         Pos
33757                         Rot [3]float32
33758
33759                         HP uint16
33760
33761                         // See (de)serialize.fmt.
33762                         Msgs []AOMsg
33763                 }))(obj)).Msgs
33764                 { // For AOInitData.Msgs.
33765                         if len(x) > math.MaxUint8 {
33766                                 chk(ErrTooLong)
33767                         }
33768                         write8(w, uint8(len(x)))
33769                         for _, msg := range x {
33770                                 var b bytes.Buffer
33771                                 chk(writeAOMsg(&b, msg))
33772                                 if b.Len() > math.MaxUint32 {
33773                                         chk(ErrTooLong)
33774                                 }
33775                                 write32(w, uint32(b.Len()))
33776                                 _, err := b.WriteTo(w)
33777                                 chk(err)
33778                         }
33779                 }
33780         }
33781 }
33782
33783 func (obj *AOInitData) deserialize(r io.Reader) {
33784         {
33785                 var local391 uint8
33786                 local392 := uint8(1)
33787                 {
33788                         p := &local391
33789                         *p = read8(r)
33790                 }
33791                 if local391 != local392 {
33792                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local391))
33793                 }
33794         }
33795         var local393 []uint8
33796         var local394 uint16
33797         {
33798                 p := &local394
33799                 *p = read16(r)
33800         }
33801         (local393) = make([]uint8, local394)
33802         {
33803                 _, err := io.ReadFull(r, (local393)[:])
33804                 chk(err)
33805         }
33806         ((*(*(struct {
33807
33808                 // For players.
33809                 Name     string
33810                 IsPlayer bool
33811
33812                 ID AOID
33813
33814                 Pos
33815                 Rot [3]float32
33816
33817                 HP uint16
33818
33819                 // See (de)serialize.fmt.
33820                 Msgs []AOMsg
33821         }))(obj)).Name) = string(local393)
33822         {
33823                 p := &(*(*(struct {
33824
33825                         // For players.
33826                         Name     string
33827                         IsPlayer bool
33828
33829                         ID AOID
33830
33831                         Pos
33832                         Rot [3]float32
33833
33834                         HP uint16
33835
33836                         // See (de)serialize.fmt.
33837                         Msgs []AOMsg
33838                 }))(obj)).IsPlayer
33839                 switch n := read8(r); n {
33840                 case 0:
33841                         *p = false
33842                 case 1:
33843                         *p = true
33844                 default:
33845                         chk(fmt.Errorf("invalid bool: %d", n))
33846                 }
33847         }
33848         if err := pcall(func() {
33849                 ((*(*(struct {
33850
33851                         // For players.
33852                         Name     string
33853                         IsPlayer bool
33854
33855                         ID AOID
33856
33857                         Pos
33858                         Rot [3]float32
33859
33860                         HP uint16
33861
33862                         // See (de)serialize.fmt.
33863                         Msgs []AOMsg
33864                 }))(obj)).ID).deserialize(r)
33865         }); err != nil {
33866                 if err == io.EOF {
33867                         chk(io.EOF)
33868                 }
33869                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
33870         }
33871         if err := pcall(func() {
33872                 ((*(*(struct {
33873
33874                         // For players.
33875                         Name     string
33876                         IsPlayer bool
33877
33878                         ID AOID
33879
33880                         Pos
33881                         Rot [3]float32
33882
33883                         HP uint16
33884
33885                         // See (de)serialize.fmt.
33886                         Msgs []AOMsg
33887                 }))(obj)).Pos).deserialize(r)
33888         }); err != nil {
33889                 if err == io.EOF {
33890                         chk(io.EOF)
33891                 }
33892                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
33893         }
33894         for local395 := range (*(*(struct {
33895
33896                 // For players.
33897                 Name     string
33898                 IsPlayer bool
33899
33900                 ID AOID
33901
33902                 Pos
33903                 Rot [3]float32
33904
33905                 HP uint16
33906
33907                 // See (de)serialize.fmt.
33908                 Msgs []AOMsg
33909         }))(obj)).Rot {
33910                 {
33911                         p := &((*(*(struct {
33912
33913                                 // For players.
33914                                 Name     string
33915                                 IsPlayer bool
33916
33917                                 ID AOID
33918
33919                                 Pos
33920                                 Rot [3]float32
33921
33922                                 HP uint16
33923
33924                                 // See (de)serialize.fmt.
33925                                 Msgs []AOMsg
33926                         }))(obj)).Rot)[local395]
33927                         *p = math.Float32frombits(read32(r))
33928                 }
33929         }
33930         {
33931                 p := &(*(*(struct {
33932
33933                         // For players.
33934                         Name     string
33935                         IsPlayer bool
33936
33937                         ID AOID
33938
33939                         Pos
33940                         Rot [3]float32
33941
33942                         HP uint16
33943
33944                         // See (de)serialize.fmt.
33945                         Msgs []AOMsg
33946                 }))(obj)).HP
33947                 *p = read16(r)
33948         }
33949         {
33950                 p := &(*(*(struct {
33951
33952                         // For players.
33953                         Name     string
33954                         IsPlayer bool
33955
33956                         ID AOID
33957
33958                         Pos
33959                         Rot [3]float32
33960
33961                         HP uint16
33962
33963                         // See (de)serialize.fmt.
33964                         Msgs []AOMsg
33965                 }))(obj)).Msgs
33966                 { // For AOInitData.Msgs.
33967                         *p = make([]AOMsg, read8(r))
33968                         for i := range *p {
33969                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
33970                                 msg, err := readAOMsg(r)
33971                                 chk(err)
33972                                 (*p)[i] = msg
33973                                 if r.N > 0 {
33974                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
33975                                 }
33976                         }
33977                 }
33978         }
33979 }
33980
33981 func (obj *ItemType) serialize(w io.Writer) {
33982         {
33983                 x := *(*(uint8))(obj)
33984                 write8(w, uint8(x))
33985         }
33986 }
33987
33988 func (obj *ItemType) deserialize(r io.Reader) {
33989         {
33990                 p := &*(*(uint8))(obj)
33991                 *p = read8(r)
33992         }
33993 }
33994
33995 func (obj *ToolCaps) serialize(w io.Writer) {
33996         if _ = (*(*(struct {
33997                 //mt:if _ = %s; false
33998                 NonNil bool
33999
34000                 AttackCooldown float32
34001                 MaxDropLvl     int16
34002
34003                 //mt:len32
34004                 GroupCaps []ToolGroupCap
34005
34006                 //mt:len32
34007                 DmgGroups []Group
34008
34009                 //mt:32tou16
34010                 PunchUses int32
34011         }))(obj)); false {
34012                 {
34013                         x := (*(*(struct {
34014                                 //mt:if _ = %s; false
34015                                 NonNil bool
34016
34017                                 AttackCooldown float32
34018                                 MaxDropLvl     int16
34019
34020                                 //mt:len32
34021                                 GroupCaps []ToolGroupCap
34022
34023                                 //mt:len32
34024                                 DmgGroups []Group
34025
34026                                 //mt:32tou16
34027                                 PunchUses int32
34028                         }))(obj)).NonNil
34029                         if x {
34030                                 write8(w, 1)
34031                         } else {
34032                                 write8(w, 0)
34033                         }
34034                 }
34035         }
34036         {
34037                 ow := w
34038                 w := new(bytes.Buffer)
34039                 /*
34040                    if r.N > 0 { (*(*(struct {
34041                         //mt:if _ = %s; false
34042                         NonNil  bool
34043
34044                         AttackCooldown  float32
34045                         MaxDropLvl      int16
34046
34047                         //mt:len32
34048                         GroupCaps       []ToolGroupCap
34049
34050                         //mt:len32
34051                         DmgGroups       []Group
34052
34053                         //mt:32tou16
34054                         PunchUses       int32
34055                    }))(obj)).NonNil = true}; /**/{
34056                         if (*(*(struct {
34057                                 //mt:if _ = %s; false
34058                                 NonNil bool
34059
34060                                 AttackCooldown float32
34061                                 MaxDropLvl     int16
34062
34063                                 //mt:len32
34064                                 GroupCaps []ToolGroupCap
34065
34066                                 //mt:len32
34067                                 DmgGroups []Group
34068
34069                                 //mt:32tou16
34070                                 PunchUses int32
34071                         }))(obj)).NonNil {
34072                                 {
34073                                         local396 := uint8(5)
34074                                         {
34075                                                 x := local396
34076                                                 write8(w, uint8(x))
34077                                         }
34078                                 }
34079                                 {
34080                                         x := (*(*(struct {
34081                                                 //mt:if _ = %s; false
34082                                                 NonNil bool
34083
34084                                                 AttackCooldown float32
34085                                                 MaxDropLvl     int16
34086
34087                                                 //mt:len32
34088                                                 GroupCaps []ToolGroupCap
34089
34090                                                 //mt:len32
34091                                                 DmgGroups []Group
34092
34093                                                 //mt:32tou16
34094                                                 PunchUses int32
34095                                         }))(obj)).AttackCooldown
34096                                         write32(w, math.Float32bits(x))
34097                                 }
34098                                 {
34099                                         x := (*(*(struct {
34100                                                 //mt:if _ = %s; false
34101                                                 NonNil bool
34102
34103                                                 AttackCooldown float32
34104                                                 MaxDropLvl     int16
34105
34106                                                 //mt:len32
34107                                                 GroupCaps []ToolGroupCap
34108
34109                                                 //mt:len32
34110                                                 DmgGroups []Group
34111
34112                                                 //mt:32tou16
34113                                                 PunchUses int32
34114                                         }))(obj)).MaxDropLvl
34115                                         write16(w, uint16(x))
34116                                 }
34117                                 if len(((*(*(struct {
34118                                         //mt:if _ = %s; false
34119                                         NonNil bool
34120
34121                                         AttackCooldown float32
34122                                         MaxDropLvl     int16
34123
34124                                         //mt:len32
34125                                         GroupCaps []ToolGroupCap
34126
34127                                         //mt:len32
34128                                         DmgGroups []Group
34129
34130                                         //mt:32tou16
34131                                         PunchUses int32
34132                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
34133                                         chk(ErrTooLong)
34134                                 }
34135                                 {
34136                                         x := uint32(len(((*(*(struct {
34137                                                 //mt:if _ = %s; false
34138                                                 NonNil bool
34139
34140                                                 AttackCooldown float32
34141                                                 MaxDropLvl     int16
34142
34143                                                 //mt:len32
34144                                                 GroupCaps []ToolGroupCap
34145
34146                                                 //mt:len32
34147                                                 DmgGroups []Group
34148
34149                                                 //mt:32tou16
34150                                                 PunchUses int32
34151                                         }))(obj)).GroupCaps)))
34152                                         write32(w, uint32(x))
34153                                 }
34154                                 for local397 := range (*(*(struct {
34155                                         //mt:if _ = %s; false
34156                                         NonNil bool
34157
34158                                         AttackCooldown float32
34159                                         MaxDropLvl     int16
34160
34161                                         //mt:len32
34162                                         GroupCaps []ToolGroupCap
34163
34164                                         //mt:len32
34165                                         DmgGroups []Group
34166
34167                                         //mt:32tou16
34168                                         PunchUses int32
34169                                 }))(obj)).GroupCaps {
34170                                         if err := pcall(func() {
34171                                                 (((*(*(struct {
34172                                                         //mt:if _ = %s; false
34173                                                         NonNil bool
34174
34175                                                         AttackCooldown float32
34176                                                         MaxDropLvl     int16
34177
34178                                                         //mt:len32
34179                                                         GroupCaps []ToolGroupCap
34180
34181                                                         //mt:len32
34182                                                         DmgGroups []Group
34183
34184                                                         //mt:32tou16
34185                                                         PunchUses int32
34186                                                 }))(obj)).GroupCaps)[local397]).serialize(w)
34187                                         }); err != nil {
34188                                                 if err == io.EOF {
34189                                                         chk(io.EOF)
34190                                                 }
34191                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
34192                                         }
34193                                 }
34194                                 if len(((*(*(struct {
34195                                         //mt:if _ = %s; false
34196                                         NonNil bool
34197
34198                                         AttackCooldown float32
34199                                         MaxDropLvl     int16
34200
34201                                         //mt:len32
34202                                         GroupCaps []ToolGroupCap
34203
34204                                         //mt:len32
34205                                         DmgGroups []Group
34206
34207                                         //mt:32tou16
34208                                         PunchUses int32
34209                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
34210                                         chk(ErrTooLong)
34211                                 }
34212                                 {
34213                                         x := uint32(len(((*(*(struct {
34214                                                 //mt:if _ = %s; false
34215                                                 NonNil bool
34216
34217                                                 AttackCooldown float32
34218                                                 MaxDropLvl     int16
34219
34220                                                 //mt:len32
34221                                                 GroupCaps []ToolGroupCap
34222
34223                                                 //mt:len32
34224                                                 DmgGroups []Group
34225
34226                                                 //mt:32tou16
34227                                                 PunchUses int32
34228                                         }))(obj)).DmgGroups)))
34229                                         write32(w, uint32(x))
34230                                 }
34231                                 for local398 := range (*(*(struct {
34232                                         //mt:if _ = %s; false
34233                                         NonNil bool
34234
34235                                         AttackCooldown float32
34236                                         MaxDropLvl     int16
34237
34238                                         //mt:len32
34239                                         GroupCaps []ToolGroupCap
34240
34241                                         //mt:len32
34242                                         DmgGroups []Group
34243
34244                                         //mt:32tou16
34245                                         PunchUses int32
34246                                 }))(obj)).DmgGroups {
34247                                         if err := pcall(func() {
34248                                                 (((*(*(struct {
34249                                                         //mt:if _ = %s; false
34250                                                         NonNil bool
34251
34252                                                         AttackCooldown float32
34253                                                         MaxDropLvl     int16
34254
34255                                                         //mt:len32
34256                                                         GroupCaps []ToolGroupCap
34257
34258                                                         //mt:len32
34259                                                         DmgGroups []Group
34260
34261                                                         //mt:32tou16
34262                                                         PunchUses int32
34263                                                 }))(obj)).DmgGroups)[local398]).serialize(w)
34264                                         }); err != nil {
34265                                                 if err == io.EOF {
34266                                                         chk(io.EOF)
34267                                                 }
34268                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
34269                                         }
34270                                 }
34271                                 {
34272                                         x := uint16((*(*(struct {
34273                                                 //mt:if _ = %s; false
34274                                                 NonNil bool
34275
34276                                                 AttackCooldown float32
34277                                                 MaxDropLvl     int16
34278
34279                                                 //mt:len32
34280                                                 GroupCaps []ToolGroupCap
34281
34282                                                 //mt:len32
34283                                                 DmgGroups []Group
34284
34285                                                 //mt:32tou16
34286                                                 PunchUses int32
34287                                         }))(obj)).PunchUses)
34288                                         write16(w, uint16(x))
34289                                 }
34290                         }
34291                 }
34292                 {
34293                         buf := w
34294                         w := ow
34295                         if len((buf.Bytes())) > math.MaxUint16 {
34296                                 chk(ErrTooLong)
34297                         }
34298                         {
34299                                 x := uint16(len((buf.Bytes())))
34300                                 write16(w, uint16(x))
34301                         }
34302                         {
34303                                 _, err := w.Write((buf.Bytes())[:])
34304                                 chk(err)
34305                         }
34306                 }
34307         }
34308 }
34309
34310 func (obj *ToolCaps) deserialize(r io.Reader) {
34311         if _ = (*(*(struct {
34312                 //mt:if _ = %s; false
34313                 NonNil bool
34314
34315                 AttackCooldown float32
34316                 MaxDropLvl     int16
34317
34318                 //mt:len32
34319                 GroupCaps []ToolGroupCap
34320
34321                 //mt:len32
34322                 DmgGroups []Group
34323
34324                 //mt:32tou16
34325                 PunchUses int32
34326         }))(obj)); false {
34327                 {
34328                         p := &(*(*(struct {
34329                                 //mt:if _ = %s; false
34330                                 NonNil bool
34331
34332                                 AttackCooldown float32
34333                                 MaxDropLvl     int16
34334
34335                                 //mt:len32
34336                                 GroupCaps []ToolGroupCap
34337
34338                                 //mt:len32
34339                                 DmgGroups []Group
34340
34341                                 //mt:32tou16
34342                                 PunchUses int32
34343                         }))(obj)).NonNil
34344                         switch n := read8(r); n {
34345                         case 0:
34346                                 *p = false
34347                         case 1:
34348                                 *p = true
34349                         default:
34350                                 chk(fmt.Errorf("invalid bool: %d", n))
34351                         }
34352                 }
34353         }
34354         {
34355                 var n uint16
34356                 {
34357                         p := &n
34358                         *p = read16(r)
34359                 }
34360                 r := &io.LimitedReader{R: r, N: int64(n)}
34361                 if r.N > 0 {
34362                         (*(*(struct {
34363                                 //mt:if _ = %s; false
34364                                 NonNil bool
34365
34366                                 AttackCooldown float32
34367                                 MaxDropLvl     int16
34368
34369                                 //mt:len32
34370                                 GroupCaps []ToolGroupCap
34371
34372                                 //mt:len32
34373                                 DmgGroups []Group
34374
34375                                 //mt:32tou16
34376                                 PunchUses int32
34377                         }))(obj)).NonNil = true
34378                 } /**/
34379                 {
34380                         if (*(*(struct {
34381                                 //mt:if _ = %s; false
34382                                 NonNil bool
34383
34384                                 AttackCooldown float32
34385                                 MaxDropLvl     int16
34386
34387                                 //mt:len32
34388                                 GroupCaps []ToolGroupCap
34389
34390                                 //mt:len32
34391                                 DmgGroups []Group
34392
34393                                 //mt:32tou16
34394                                 PunchUses int32
34395                         }))(obj)).NonNil {
34396                                 {
34397                                         var local399 uint8
34398                                         local400 := uint8(5)
34399                                         {
34400                                                 p := &local399
34401                                                 *p = read8(r)
34402                                         }
34403                                         if local399 != local400 {
34404                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local399))
34405                                         }
34406                                 }
34407                                 {
34408                                         p := &(*(*(struct {
34409                                                 //mt:if _ = %s; false
34410                                                 NonNil bool
34411
34412                                                 AttackCooldown float32
34413                                                 MaxDropLvl     int16
34414
34415                                                 //mt:len32
34416                                                 GroupCaps []ToolGroupCap
34417
34418                                                 //mt:len32
34419                                                 DmgGroups []Group
34420
34421                                                 //mt:32tou16
34422                                                 PunchUses int32
34423                                         }))(obj)).AttackCooldown
34424                                         *p = math.Float32frombits(read32(r))
34425                                 }
34426                                 {
34427                                         p := &(*(*(struct {
34428                                                 //mt:if _ = %s; false
34429                                                 NonNil bool
34430
34431                                                 AttackCooldown float32
34432                                                 MaxDropLvl     int16
34433
34434                                                 //mt:len32
34435                                                 GroupCaps []ToolGroupCap
34436
34437                                                 //mt:len32
34438                                                 DmgGroups []Group
34439
34440                                                 //mt:32tou16
34441                                                 PunchUses int32
34442                                         }))(obj)).MaxDropLvl
34443                                         *p = int16(read16(r))
34444                                 }
34445                                 var local401 uint32
34446                                 {
34447                                         p := &local401
34448                                         *p = read32(r)
34449                                 }
34450                                 ((*(*(struct {
34451                                         //mt:if _ = %s; false
34452                                         NonNil bool
34453
34454                                         AttackCooldown float32
34455                                         MaxDropLvl     int16
34456
34457                                         //mt:len32
34458                                         GroupCaps []ToolGroupCap
34459
34460                                         //mt:len32
34461                                         DmgGroups []Group
34462
34463                                         //mt:32tou16
34464                                         PunchUses int32
34465                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local401)
34466                                 for local402 := range (*(*(struct {
34467                                         //mt:if _ = %s; false
34468                                         NonNil bool
34469
34470                                         AttackCooldown float32
34471                                         MaxDropLvl     int16
34472
34473                                         //mt:len32
34474                                         GroupCaps []ToolGroupCap
34475
34476                                         //mt:len32
34477                                         DmgGroups []Group
34478
34479                                         //mt:32tou16
34480                                         PunchUses int32
34481                                 }))(obj)).GroupCaps {
34482                                         if err := pcall(func() {
34483                                                 (((*(*(struct {
34484                                                         //mt:if _ = %s; false
34485                                                         NonNil bool
34486
34487                                                         AttackCooldown float32
34488                                                         MaxDropLvl     int16
34489
34490                                                         //mt:len32
34491                                                         GroupCaps []ToolGroupCap
34492
34493                                                         //mt:len32
34494                                                         DmgGroups []Group
34495
34496                                                         //mt:32tou16
34497                                                         PunchUses int32
34498                                                 }))(obj)).GroupCaps)[local402]).deserialize(r)
34499                                         }); err != nil {
34500                                                 if err == io.EOF {
34501                                                         chk(io.EOF)
34502                                                 }
34503                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
34504                                         }
34505                                 }
34506                                 var local403 uint32
34507                                 {
34508                                         p := &local403
34509                                         *p = read32(r)
34510                                 }
34511                                 ((*(*(struct {
34512                                         //mt:if _ = %s; false
34513                                         NonNil bool
34514
34515                                         AttackCooldown float32
34516                                         MaxDropLvl     int16
34517
34518                                         //mt:len32
34519                                         GroupCaps []ToolGroupCap
34520
34521                                         //mt:len32
34522                                         DmgGroups []Group
34523
34524                                         //mt:32tou16
34525                                         PunchUses int32
34526                                 }))(obj)).DmgGroups) = make([]Group, local403)
34527                                 for local404 := range (*(*(struct {
34528                                         //mt:if _ = %s; false
34529                                         NonNil bool
34530
34531                                         AttackCooldown float32
34532                                         MaxDropLvl     int16
34533
34534                                         //mt:len32
34535                                         GroupCaps []ToolGroupCap
34536
34537                                         //mt:len32
34538                                         DmgGroups []Group
34539
34540                                         //mt:32tou16
34541                                         PunchUses int32
34542                                 }))(obj)).DmgGroups {
34543                                         if err := pcall(func() {
34544                                                 (((*(*(struct {
34545                                                         //mt:if _ = %s; false
34546                                                         NonNil bool
34547
34548                                                         AttackCooldown float32
34549                                                         MaxDropLvl     int16
34550
34551                                                         //mt:len32
34552                                                         GroupCaps []ToolGroupCap
34553
34554                                                         //mt:len32
34555                                                         DmgGroups []Group
34556
34557                                                         //mt:32tou16
34558                                                         PunchUses int32
34559                                                 }))(obj)).DmgGroups)[local404]).deserialize(r)
34560                                         }); err != nil {
34561                                                 if err == io.EOF {
34562                                                         chk(io.EOF)
34563                                                 }
34564                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
34565                                         }
34566                                 }
34567                                 var local405 uint16
34568                                 {
34569                                         p := &local405
34570                                         *p = read16(r)
34571                                 }
34572                                 (*(*(struct {
34573                                         //mt:if _ = %s; false
34574                                         NonNil bool
34575
34576                                         AttackCooldown float32
34577                                         MaxDropLvl     int16
34578
34579                                         //mt:len32
34580                                         GroupCaps []ToolGroupCap
34581
34582                                         //mt:len32
34583                                         DmgGroups []Group
34584
34585                                         //mt:32tou16
34586                                         PunchUses int32
34587                                 }))(obj)).PunchUses = int32(local405)
34588                         }
34589                 }
34590                 if r.N > 0 {
34591                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34592                 }
34593         }
34594 }
34595
34596 func (obj *AnimType) serialize(w io.Writer) {
34597         {
34598                 x := *(*(uint8))(obj)
34599                 write8(w, uint8(x))
34600         }
34601 }
34602
34603 func (obj *AnimType) deserialize(r io.Reader) {
34604         {
34605                 p := &*(*(uint8))(obj)
34606                 *p = read8(r)
34607         }
34608 }
34609
34610 func (obj *HUDType) serialize(w io.Writer) {
34611         {
34612                 x := *(*(uint8))(obj)
34613                 write8(w, uint8(x))
34614         }
34615 }
34616
34617 func (obj *HUDType) deserialize(r io.Reader) {
34618         {
34619                 p := &*(*(uint8))(obj)
34620                 *p = read8(r)
34621         }
34622 }
34623
34624 func (obj *Box) serialize(w io.Writer) {
34625         for local406 := range *(*([2]Vec))(obj) {
34626                 if err := pcall(func() {
34627                         ((*(*([2]Vec))(obj))[local406]).serialize(w)
34628                 }); err != nil {
34629                         if err == io.EOF {
34630                                 chk(io.EOF)
34631                         }
34632                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
34633                 }
34634         }
34635 }
34636
34637 func (obj *Box) deserialize(r io.Reader) {
34638         for local407 := range *(*([2]Vec))(obj) {
34639                 if err := pcall(func() {
34640                         ((*(*([2]Vec))(obj))[local407]).deserialize(r)
34641                 }); err != nil {
34642                         if err == io.EOF {
34643                                 chk(io.EOF)
34644                         }
34645                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
34646                 }
34647         }
34648 }
34649
34650 func (obj *TileFlags) serialize(w io.Writer) {
34651         {
34652                 x := *(*(uint16))(obj)
34653                 write16(w, uint16(x))
34654         }
34655 }
34656
34657 func (obj *TileFlags) deserialize(r io.Reader) {
34658         {
34659                 p := &*(*(uint16))(obj)
34660                 *p = read16(r)
34661         }
34662 }
34663
34664 func (obj *AlignType) serialize(w io.Writer) {
34665         {
34666                 x := *(*(uint8))(obj)
34667                 write8(w, uint8(x))
34668         }
34669 }
34670
34671 func (obj *AlignType) deserialize(r io.Reader) {
34672         {
34673                 p := &*(*(uint8))(obj)
34674                 *p = read8(r)
34675         }
34676 }
34677
34678 func (obj *NodeBoxType) serialize(w io.Writer) {
34679         {
34680                 x := *(*(uint8))(obj)
34681                 write8(w, uint8(x))
34682         }
34683 }
34684
34685 func (obj *NodeBoxType) deserialize(r io.Reader) {
34686         {
34687                 p := &*(*(uint8))(obj)
34688                 *p = read8(r)
34689         }
34690 }
34691
34692 func (obj *DirBoxes) serialize(w io.Writer) {
34693         if len(((*(*(struct {
34694                 Top, Bot                 []Box
34695                 Front, Left, Back, Right []Box
34696         }))(obj)).Top)) > math.MaxUint16 {
34697                 chk(ErrTooLong)
34698         }
34699         {
34700                 x := uint16(len(((*(*(struct {
34701                         Top, Bot                 []Box
34702                         Front, Left, Back, Right []Box
34703                 }))(obj)).Top)))
34704                 write16(w, uint16(x))
34705         }
34706         for local408 := range (*(*(struct {
34707                 Top, Bot                 []Box
34708                 Front, Left, Back, Right []Box
34709         }))(obj)).Top {
34710                 if err := pcall(func() {
34711                         (((*(*(struct {
34712                                 Top, Bot                 []Box
34713                                 Front, Left, Back, Right []Box
34714                         }))(obj)).Top)[local408]).serialize(w)
34715                 }); err != nil {
34716                         if err == io.EOF {
34717                                 chk(io.EOF)
34718                         }
34719                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34720                 }
34721         }
34722         if len(((*(*(struct {
34723                 Top, Bot                 []Box
34724                 Front, Left, Back, Right []Box
34725         }))(obj)).Bot)) > math.MaxUint16 {
34726                 chk(ErrTooLong)
34727         }
34728         {
34729                 x := uint16(len(((*(*(struct {
34730                         Top, Bot                 []Box
34731                         Front, Left, Back, Right []Box
34732                 }))(obj)).Bot)))
34733                 write16(w, uint16(x))
34734         }
34735         for local409 := range (*(*(struct {
34736                 Top, Bot                 []Box
34737                 Front, Left, Back, Right []Box
34738         }))(obj)).Bot {
34739                 if err := pcall(func() {
34740                         (((*(*(struct {
34741                                 Top, Bot                 []Box
34742                                 Front, Left, Back, Right []Box
34743                         }))(obj)).Bot)[local409]).serialize(w)
34744                 }); err != nil {
34745                         if err == io.EOF {
34746                                 chk(io.EOF)
34747                         }
34748                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34749                 }
34750         }
34751         if len(((*(*(struct {
34752                 Top, Bot                 []Box
34753                 Front, Left, Back, Right []Box
34754         }))(obj)).Front)) > math.MaxUint16 {
34755                 chk(ErrTooLong)
34756         }
34757         {
34758                 x := uint16(len(((*(*(struct {
34759                         Top, Bot                 []Box
34760                         Front, Left, Back, Right []Box
34761                 }))(obj)).Front)))
34762                 write16(w, uint16(x))
34763         }
34764         for local410 := range (*(*(struct {
34765                 Top, Bot                 []Box
34766                 Front, Left, Back, Right []Box
34767         }))(obj)).Front {
34768                 if err := pcall(func() {
34769                         (((*(*(struct {
34770                                 Top, Bot                 []Box
34771                                 Front, Left, Back, Right []Box
34772                         }))(obj)).Front)[local410]).serialize(w)
34773                 }); err != nil {
34774                         if err == io.EOF {
34775                                 chk(io.EOF)
34776                         }
34777                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34778                 }
34779         }
34780         if len(((*(*(struct {
34781                 Top, Bot                 []Box
34782                 Front, Left, Back, Right []Box
34783         }))(obj)).Left)) > math.MaxUint16 {
34784                 chk(ErrTooLong)
34785         }
34786         {
34787                 x := uint16(len(((*(*(struct {
34788                         Top, Bot                 []Box
34789                         Front, Left, Back, Right []Box
34790                 }))(obj)).Left)))
34791                 write16(w, uint16(x))
34792         }
34793         for local411 := range (*(*(struct {
34794                 Top, Bot                 []Box
34795                 Front, Left, Back, Right []Box
34796         }))(obj)).Left {
34797                 if err := pcall(func() {
34798                         (((*(*(struct {
34799                                 Top, Bot                 []Box
34800                                 Front, Left, Back, Right []Box
34801                         }))(obj)).Left)[local411]).serialize(w)
34802                 }); err != nil {
34803                         if err == io.EOF {
34804                                 chk(io.EOF)
34805                         }
34806                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34807                 }
34808         }
34809         if len(((*(*(struct {
34810                 Top, Bot                 []Box
34811                 Front, Left, Back, Right []Box
34812         }))(obj)).Back)) > math.MaxUint16 {
34813                 chk(ErrTooLong)
34814         }
34815         {
34816                 x := uint16(len(((*(*(struct {
34817                         Top, Bot                 []Box
34818                         Front, Left, Back, Right []Box
34819                 }))(obj)).Back)))
34820                 write16(w, uint16(x))
34821         }
34822         for local412 := range (*(*(struct {
34823                 Top, Bot                 []Box
34824                 Front, Left, Back, Right []Box
34825         }))(obj)).Back {
34826                 if err := pcall(func() {
34827                         (((*(*(struct {
34828                                 Top, Bot                 []Box
34829                                 Front, Left, Back, Right []Box
34830                         }))(obj)).Back)[local412]).serialize(w)
34831                 }); err != nil {
34832                         if err == io.EOF {
34833                                 chk(io.EOF)
34834                         }
34835                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34836                 }
34837         }
34838         if len(((*(*(struct {
34839                 Top, Bot                 []Box
34840                 Front, Left, Back, Right []Box
34841         }))(obj)).Right)) > math.MaxUint16 {
34842                 chk(ErrTooLong)
34843         }
34844         {
34845                 x := uint16(len(((*(*(struct {
34846                         Top, Bot                 []Box
34847                         Front, Left, Back, Right []Box
34848                 }))(obj)).Right)))
34849                 write16(w, uint16(x))
34850         }
34851         for local413 := range (*(*(struct {
34852                 Top, Bot                 []Box
34853                 Front, Left, Back, Right []Box
34854         }))(obj)).Right {
34855                 if err := pcall(func() {
34856                         (((*(*(struct {
34857                                 Top, Bot                 []Box
34858                                 Front, Left, Back, Right []Box
34859                         }))(obj)).Right)[local413]).serialize(w)
34860                 }); err != nil {
34861                         if err == io.EOF {
34862                                 chk(io.EOF)
34863                         }
34864                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34865                 }
34866         }
34867 }
34868
34869 func (obj *DirBoxes) deserialize(r io.Reader) {
34870         var local414 uint16
34871         {
34872                 p := &local414
34873                 *p = read16(r)
34874         }
34875         ((*(*(struct {
34876                 Top, Bot                 []Box
34877                 Front, Left, Back, Right []Box
34878         }))(obj)).Top) = make([]Box, local414)
34879         for local415 := range (*(*(struct {
34880                 Top, Bot                 []Box
34881                 Front, Left, Back, Right []Box
34882         }))(obj)).Top {
34883                 if err := pcall(func() {
34884                         (((*(*(struct {
34885                                 Top, Bot                 []Box
34886                                 Front, Left, Back, Right []Box
34887                         }))(obj)).Top)[local415]).deserialize(r)
34888                 }); err != nil {
34889                         if err == io.EOF {
34890                                 chk(io.EOF)
34891                         }
34892                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34893                 }
34894         }
34895         var local416 uint16
34896         {
34897                 p := &local416
34898                 *p = read16(r)
34899         }
34900         ((*(*(struct {
34901                 Top, Bot                 []Box
34902                 Front, Left, Back, Right []Box
34903         }))(obj)).Bot) = make([]Box, local416)
34904         for local417 := range (*(*(struct {
34905                 Top, Bot                 []Box
34906                 Front, Left, Back, Right []Box
34907         }))(obj)).Bot {
34908                 if err := pcall(func() {
34909                         (((*(*(struct {
34910                                 Top, Bot                 []Box
34911                                 Front, Left, Back, Right []Box
34912                         }))(obj)).Bot)[local417]).deserialize(r)
34913                 }); err != nil {
34914                         if err == io.EOF {
34915                                 chk(io.EOF)
34916                         }
34917                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34918                 }
34919         }
34920         var local418 uint16
34921         {
34922                 p := &local418
34923                 *p = read16(r)
34924         }
34925         ((*(*(struct {
34926                 Top, Bot                 []Box
34927                 Front, Left, Back, Right []Box
34928         }))(obj)).Front) = make([]Box, local418)
34929         for local419 := range (*(*(struct {
34930                 Top, Bot                 []Box
34931                 Front, Left, Back, Right []Box
34932         }))(obj)).Front {
34933                 if err := pcall(func() {
34934                         (((*(*(struct {
34935                                 Top, Bot                 []Box
34936                                 Front, Left, Back, Right []Box
34937                         }))(obj)).Front)[local419]).deserialize(r)
34938                 }); err != nil {
34939                         if err == io.EOF {
34940                                 chk(io.EOF)
34941                         }
34942                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34943                 }
34944         }
34945         var local420 uint16
34946         {
34947                 p := &local420
34948                 *p = read16(r)
34949         }
34950         ((*(*(struct {
34951                 Top, Bot                 []Box
34952                 Front, Left, Back, Right []Box
34953         }))(obj)).Left) = make([]Box, local420)
34954         for local421 := range (*(*(struct {
34955                 Top, Bot                 []Box
34956                 Front, Left, Back, Right []Box
34957         }))(obj)).Left {
34958                 if err := pcall(func() {
34959                         (((*(*(struct {
34960                                 Top, Bot                 []Box
34961                                 Front, Left, Back, Right []Box
34962                         }))(obj)).Left)[local421]).deserialize(r)
34963                 }); err != nil {
34964                         if err == io.EOF {
34965                                 chk(io.EOF)
34966                         }
34967                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34968                 }
34969         }
34970         var local422 uint16
34971         {
34972                 p := &local422
34973                 *p = read16(r)
34974         }
34975         ((*(*(struct {
34976                 Top, Bot                 []Box
34977                 Front, Left, Back, Right []Box
34978         }))(obj)).Back) = make([]Box, local422)
34979         for local423 := range (*(*(struct {
34980                 Top, Bot                 []Box
34981                 Front, Left, Back, Right []Box
34982         }))(obj)).Back {
34983                 if err := pcall(func() {
34984                         (((*(*(struct {
34985                                 Top, Bot                 []Box
34986                                 Front, Left, Back, Right []Box
34987                         }))(obj)).Back)[local423]).deserialize(r)
34988                 }); err != nil {
34989                         if err == io.EOF {
34990                                 chk(io.EOF)
34991                         }
34992                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34993                 }
34994         }
34995         var local424 uint16
34996         {
34997                 p := &local424
34998                 *p = read16(r)
34999         }
35000         ((*(*(struct {
35001                 Top, Bot                 []Box
35002                 Front, Left, Back, Right []Box
35003         }))(obj)).Right) = make([]Box, local424)
35004         for local425 := range (*(*(struct {
35005                 Top, Bot                 []Box
35006                 Front, Left, Back, Right []Box
35007         }))(obj)).Right {
35008                 if err := pcall(func() {
35009                         (((*(*(struct {
35010                                 Top, Bot                 []Box
35011                                 Front, Left, Back, Right []Box
35012                         }))(obj)).Right)[local425]).deserialize(r)
35013                 }); err != nil {
35014                         if err == io.EOF {
35015                                 chk(io.EOF)
35016                         }
35017                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35018                 }
35019         }
35020 }
35021
35022 func (obj *ToolGroupCap) serialize(w io.Writer) {
35023         if len(([]byte((*(*(struct {
35024                 Name string
35025
35026                 //mt:32to16
35027                 Uses int32
35028
35029                 MaxLvl int16
35030
35031                 //mt:len32
35032                 Times []DigTime
35033         }))(obj)).Name))) > math.MaxUint16 {
35034                 chk(ErrTooLong)
35035         }
35036         {
35037                 x := uint16(len(([]byte((*(*(struct {
35038                         Name string
35039
35040                         //mt:32to16
35041                         Uses int32
35042
35043                         MaxLvl int16
35044
35045                         //mt:len32
35046                         Times []DigTime
35047                 }))(obj)).Name))))
35048                 write16(w, uint16(x))
35049         }
35050         {
35051                 _, err := w.Write(([]byte((*(*(struct {
35052                         Name string
35053
35054                         //mt:32to16
35055                         Uses int32
35056
35057                         MaxLvl int16
35058
35059                         //mt:len32
35060                         Times []DigTime
35061                 }))(obj)).Name))[:])
35062                 chk(err)
35063         }
35064         {
35065                 x := int16((*(*(struct {
35066                         Name string
35067
35068                         //mt:32to16
35069                         Uses int32
35070
35071                         MaxLvl int16
35072
35073                         //mt:len32
35074                         Times []DigTime
35075                 }))(obj)).Uses)
35076                 write16(w, uint16(x))
35077         }
35078         {
35079                 x := (*(*(struct {
35080                         Name string
35081
35082                         //mt:32to16
35083                         Uses int32
35084
35085                         MaxLvl int16
35086
35087                         //mt:len32
35088                         Times []DigTime
35089                 }))(obj)).MaxLvl
35090                 write16(w, uint16(x))
35091         }
35092         if len(((*(*(struct {
35093                 Name string
35094
35095                 //mt:32to16
35096                 Uses int32
35097
35098                 MaxLvl int16
35099
35100                 //mt:len32
35101                 Times []DigTime
35102         }))(obj)).Times)) > math.MaxUint32 {
35103                 chk(ErrTooLong)
35104         }
35105         {
35106                 x := uint32(len(((*(*(struct {
35107                         Name string
35108
35109                         //mt:32to16
35110                         Uses int32
35111
35112                         MaxLvl int16
35113
35114                         //mt:len32
35115                         Times []DigTime
35116                 }))(obj)).Times)))
35117                 write32(w, uint32(x))
35118         }
35119         for local426 := range (*(*(struct {
35120                 Name string
35121
35122                 //mt:32to16
35123                 Uses int32
35124
35125                 MaxLvl int16
35126
35127                 //mt:len32
35128                 Times []DigTime
35129         }))(obj)).Times {
35130                 if err := pcall(func() {
35131                         (((*(*(struct {
35132                                 Name string
35133
35134                                 //mt:32to16
35135                                 Uses int32
35136
35137                                 MaxLvl int16
35138
35139                                 //mt:len32
35140                                 Times []DigTime
35141                         }))(obj)).Times)[local426]).serialize(w)
35142                 }); err != nil {
35143                         if err == io.EOF {
35144                                 chk(io.EOF)
35145                         }
35146                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
35147                 }
35148         }
35149 }
35150
35151 func (obj *ToolGroupCap) deserialize(r io.Reader) {
35152         var local427 []uint8
35153         var local428 uint16
35154         {
35155                 p := &local428
35156                 *p = read16(r)
35157         }
35158         (local427) = make([]uint8, local428)
35159         {
35160                 _, err := io.ReadFull(r, (local427)[:])
35161                 chk(err)
35162         }
35163         ((*(*(struct {
35164                 Name string
35165
35166                 //mt:32to16
35167                 Uses int32
35168
35169                 MaxLvl int16
35170
35171                 //mt:len32
35172                 Times []DigTime
35173         }))(obj)).Name) = string(local427)
35174         var local429 int16
35175         {
35176                 p := &local429
35177                 *p = int16(read16(r))
35178         }
35179         (*(*(struct {
35180                 Name string
35181
35182                 //mt:32to16
35183                 Uses int32
35184
35185                 MaxLvl int16
35186
35187                 //mt:len32
35188                 Times []DigTime
35189         }))(obj)).Uses = int32(local429)
35190         {
35191                 p := &(*(*(struct {
35192                         Name string
35193
35194                         //mt:32to16
35195                         Uses int32
35196
35197                         MaxLvl int16
35198
35199                         //mt:len32
35200                         Times []DigTime
35201                 }))(obj)).MaxLvl
35202                 *p = int16(read16(r))
35203         }
35204         var local430 uint32
35205         {
35206                 p := &local430
35207                 *p = read32(r)
35208         }
35209         ((*(*(struct {
35210                 Name string
35211
35212                 //mt:32to16
35213                 Uses int32
35214
35215                 MaxLvl int16
35216
35217                 //mt:len32
35218                 Times []DigTime
35219         }))(obj)).Times) = make([]DigTime, local430)
35220         for local431 := range (*(*(struct {
35221                 Name string
35222
35223                 //mt:32to16
35224                 Uses int32
35225
35226                 MaxLvl int16
35227
35228                 //mt:len32
35229                 Times []DigTime
35230         }))(obj)).Times {
35231                 if err := pcall(func() {
35232                         (((*(*(struct {
35233                                 Name string
35234
35235                                 //mt:32to16
35236                                 Uses int32
35237
35238                                 MaxLvl int16
35239
35240                                 //mt:len32
35241                                 Times []DigTime
35242                         }))(obj)).Times)[local431]).deserialize(r)
35243                 }); err != nil {
35244                         if err == io.EOF {
35245                                 chk(io.EOF)
35246                         }
35247                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
35248                 }
35249         }
35250 }
35251
35252 func (obj *DigTime) serialize(w io.Writer) {
35253         {
35254                 x := (*(*(struct {
35255                         Rating int16
35256                         Time   float32
35257                 }))(obj)).Rating
35258                 write16(w, uint16(x))
35259         }
35260         {
35261                 x := (*(*(struct {
35262                         Rating int16
35263                         Time   float32
35264                 }))(obj)).Time
35265                 write32(w, math.Float32bits(x))
35266         }
35267 }
35268
35269 func (obj *DigTime) deserialize(r io.Reader) {
35270         {
35271                 p := &(*(*(struct {
35272                         Rating int16
35273                         Time   float32
35274                 }))(obj)).Rating
35275                 *p = int16(read16(r))
35276         }
35277         {
35278                 p := &(*(*(struct {
35279                         Rating int16
35280                         Time   float32
35281                 }))(obj)).Time
35282                 *p = math.Float32frombits(read32(r))
35283         }
35284 }